diff --git a/src/cli/outdated_command.zig b/src/cli/outdated_command.zig
index c642b75069..df801aab49 100644
--- a/src/cli/outdated_command.zig
+++ b/src/cli/outdated_command.zig
@@ -1,4 +1,10 @@
 pub const OutdatedCommand = struct {
+    const OutdatedInfo = struct {
+        package_id: PackageID,
+        dep_id: DependencyID,
+        workspace_pkg_id: PackageID,
+        is_catalog: bool,
+    };
     fn resolveCatalogDependency(manager: *PackageManager, dep: Install.Dependency) ?Install.Dependency.Version {
         return if (dep.version.tag == .catalog) blk: {
             const catalog_dep = manager.lockfile.catalogs.get(
@@ -87,8 +93,13 @@ pub const OutdatedCommand = struct {
 
                     try updateManifestsIfNecessary(manager, workspace_pkg_ids);
                     try printOutdatedInfoTable(manager, workspace_pkg_ids, true, enable_ansi_colors);
+                } else if (manager.options.do.recursive) {
+                    const all_workspaces = getAllWorkspaces(bun.default_allocator, manager) catch bun.outOfMemory();
+                    defer bun.default_allocator.free(all_workspaces);
+
+                    try updateManifestsIfNecessary(manager, all_workspaces);
+                    try printOutdatedInfoTable(manager, all_workspaces, true, enable_ansi_colors);
                 } else {
-                    // just the current workspace
                     const root_pkg_id = manager.root_package_id.get(manager.lockfile, manager.workspace_name_hash);
                     if (root_pkg_id == invalid_package_id) return;
 
@@ -118,6 +129,23 @@ pub const OutdatedCommand = struct {
         pub fn deinit(_: @This(), _: std.mem.Allocator) void {}
     };
 
+    fn getAllWorkspaces(
+        allocator: std.mem.Allocator,
+        manager: *PackageManager,
+    ) OOM![]const PackageID {
+        const lockfile = manager.lockfile;
+        const packages = lockfile.packages.slice();
+        const pkg_resolutions = packages.items(.resolution);
+
+        var workspace_pkg_ids: std.ArrayListUnmanaged(PackageID) = .{};
+        for (pkg_resolutions, 0..) |resolution, pkg_id| {
+            if (resolution.tag != .workspace and resolution.tag != .root) continue;
+            try workspace_pkg_ids.append(allocator, @intCast(pkg_id));
+        }
+
+        return workspace_pkg_ids.toOwnedSlice(allocator);
+    }
+
     fn findMatchingWorkspaces(
         allocator: std.mem.Allocator,
         original_cwd: string,
@@ -200,6 +228,108 @@ pub const OutdatedCommand = struct {
         return workspace_pkg_ids.items;
     }
 
+    const GroupedOutdatedInfo = struct {
+        package_id: PackageID,
+        dep_id: DependencyID,
+        workspace_pkg_id: PackageID,
+        is_catalog: bool,
+        grouped_workspace_names: ?[]const u8,
+    };
+
+    fn groupCatalogDependencies(
+        manager: *PackageManager,
+        outdated_items: []const OutdatedInfo,
+        _: []const PackageID,
+    ) !std.ArrayListUnmanaged(GroupedOutdatedInfo) {
+        const allocator = bun.default_allocator;
+        const lockfile = manager.lockfile;
+        const string_buf = lockfile.buffers.string_bytes.items;
+        const packages = lockfile.packages.slice();
+        const pkg_names = packages.items(.name);
+        const dependencies = lockfile.buffers.dependencies.items;
+
+        var result = std.ArrayListUnmanaged(GroupedOutdatedInfo){};
+
+        const CatalogKey = struct {
+            name_hash: u64,
+            catalog_name_hash: u64,
+            behavior: Behavior,
+        };
+        var catalog_map = std.AutoHashMap(CatalogKey, std.ArrayList(PackageID)).init(allocator);
+        defer catalog_map.deinit();
+        defer {
+            var iter = catalog_map.iterator();
+            while (iter.next()) |entry| {
+                entry.value_ptr.deinit();
+            }
+        }
+        for (outdated_items) |item| {
+            if (item.is_catalog) {
+                const dep = dependencies[item.dep_id];
+                const name_hash = bun.hash(dep.name.slice(string_buf));
+                const catalog_name = dep.version.value.catalog.slice(string_buf);
+                const catalog_name_hash = bun.hash(catalog_name);
+                const key = CatalogKey{ .name_hash = name_hash, .catalog_name_hash = catalog_name_hash, .behavior = dep.behavior };
+
+                const entry = try catalog_map.getOrPut(key);
+                if (!entry.found_existing) {
+                    entry.value_ptr.* = std.ArrayList(PackageID).init(allocator);
+                }
+                try entry.value_ptr.append(item.workspace_pkg_id);
+            } else {
+                try result.append(allocator, .{
+                    .package_id = item.package_id,
+                    .dep_id = item.dep_id,
+                    .workspace_pkg_id = item.workspace_pkg_id,
+                    .is_catalog = false,
+                    .grouped_workspace_names = null,
+                });
+            }
+        }
+
+        // Second pass: add grouped catalog dependencies
+        for (outdated_items) |item| {
+            if (!item.is_catalog) continue;
+
+            const dep = dependencies[item.dep_id];
+            const name_hash = bun.hash(dep.name.slice(string_buf));
+            const catalog_name = dep.version.value.catalog.slice(string_buf);
+            const catalog_name_hash = bun.hash(catalog_name);
+            const key = CatalogKey{ .name_hash = name_hash, .catalog_name_hash = catalog_name_hash, .behavior = dep.behavior };
+
+            const workspace_list = catalog_map.get(key) orelse continue;
+
+            if (workspace_list.items[0] != item.workspace_pkg_id) continue;
+            var workspace_names = std.ArrayList(u8).init(allocator);
+            defer workspace_names.deinit();
+
+            const cat_name = dep.version.value.catalog.slice(string_buf);
+            if (cat_name.len > 0) {
+                try workspace_names.appendSlice("catalog:");
+                try workspace_names.appendSlice(cat_name);
+                try workspace_names.appendSlice(" (");
+            } else {
+                try workspace_names.appendSlice("catalog (");
+            }
+            for (workspace_list.items, 0..) |workspace_id, i| {
+                if (i > 0) try workspace_names.appendSlice(", ");
+                const workspace_name = pkg_names[workspace_id].slice(string_buf);
+                try workspace_names.appendSlice(workspace_name);
+            }
+            try workspace_names.append(')');
+
+            try result.append(allocator, .{
+                .package_id = item.package_id,
+                .dep_id = item.dep_id,
+                .workspace_pkg_id = item.workspace_pkg_id,
+                .is_catalog = true,
+                .grouped_workspace_names = try workspace_names.toOwnedSlice(),
+            });
+        }
+
+        return result;
+    }
+
     fn printOutdatedInfoTable(
         manager: *PackageManager,
         workspace_pkg_ids: []const PackageID,
@@ -261,7 +391,7 @@ pub const OutdatedCommand = struct {
         defer version_buf.deinit();
         const version_writer = version_buf.writer();
 
-        var outdated_ids: std.ArrayListUnmanaged(struct { package_id: PackageID, dep_id: DependencyID, workspace_pkg_id: PackageID }) = .{};
+        var outdated_ids: std.ArrayListUnmanaged(OutdatedInfo) = .{};
         defer outdated_ids.deinit(manager.allocator);
 
         for (workspace_pkg_ids) |workspace_pkg_id| {
@@ -350,6 +480,7 @@ pub const OutdatedCommand = struct {
                         .package_id = package_id,
                         .dep_id = @intCast(dep_id),
                         .workspace_pkg_id = workspace_pkg_id,
+                        .is_catalog = dep.version.tag == .catalog,
                     },
                 ) catch bun.outOfMemory();
             }
@@ -357,11 +488,23 @@ pub const OutdatedCommand = struct {
 
         if (outdated_ids.items.len == 0) return;
 
+        // Group catalog dependencies
+        var grouped_ids = try groupCatalogDependencies(manager, outdated_ids.items, workspace_pkg_ids);
+        defer grouped_ids.deinit(bun.default_allocator);
+
+        // Recalculate max workspace length after grouping
+        var new_max_workspace: usize = max_workspace;
+        for (grouped_ids.items) |item| {
+            if (item.grouped_workspace_names) |names| {
+                if (names.len > new_max_workspace) new_max_workspace = names.len;
+            }
+        }
+
         const package_column_inside_length = @max("Packages".len, max_name);
         const current_column_inside_length = @max("Current".len, max_current);
         const update_column_inside_length = @max("Update".len, max_update);
         const latest_column_inside_length = @max("Latest".len, max_latest);
-        const workspace_column_inside_length = @max("Workspace".len, max_workspace);
+        const workspace_column_inside_length = @max("Workspace".len, new_max_workspace);
 
         const column_left_pad = 1;
         const column_right_pad = 1;
@@ -402,105 +545,106 @@ pub const OutdatedCommand = struct {
         table.printTopLineSeparator();
         table.printColumnNames();
 
-        for (workspace_pkg_ids) |workspace_pkg_id| {
-            inline for ([_]Behavior{
-                .{ .prod = true },
-                .{ .dev = true },
-                .{ .peer = true },
-                .{ .optional = true },
-            }) |group_behavior| {
-                for (outdated_ids.items) |ids| {
-                    if (workspace_pkg_id != ids.workspace_pkg_id) continue;
-                    const package_id = ids.package_id;
-                    const dep_id = ids.dep_id;
+        // Print grouped items sorted by behavior type
+        inline for ([_]Behavior{
+            .{ .prod = true },
+            .{ .dev = true },
+            .{ .peer = true },
+            .{ .optional = true },
+        }) |group_behavior| {
+            for (grouped_ids.items) |item| {
+                const package_id = item.package_id;
+                const dep_id = item.dep_id;
 
-                    const dep = dependencies[dep_id];
-                    if (!dep.behavior.includes(group_behavior)) continue;
+                const dep = dependencies[dep_id];
+                if (!dep.behavior.includes(group_behavior)) continue;
 
-                    const package_name = pkg_names[package_id].slice(string_buf);
-                    const resolution = pkg_resolutions[package_id];
+                const package_name = pkg_names[package_id].slice(string_buf);
+                const resolution = pkg_resolutions[package_id];
 
-                    var expired = false;
-                    const manifest = manager.manifests.byNameAllowExpired(
-                        manager,
-                        manager.scopeForPackageName(package_name),
-                        package_name,
-                        &expired,
-                        .load_from_memory_fallback_to_disk,
-                    ) orelse continue;
+                var expired = false;
+                const manifest = manager.manifests.byNameAllowExpired(
+                    manager,
+                    manager.scopeForPackageName(package_name),
+                    package_name,
+                    &expired,
+                    .load_from_memory_fallback_to_disk,
+                ) orelse continue;
 
-                    const latest = manifest.findByDistTag("latest") orelse continue;
-                    const resolved_version = resolveCatalogDependency(manager, dep) orelse continue;
-                    const update = if (resolved_version.tag == .npm)
-                        manifest.findBestVersion(resolved_version.value.npm.version, string_buf) orelse continue
+                const latest = manifest.findByDistTag("latest") orelse continue;
+                const resolved_version = resolveCatalogDependency(manager, dep) orelse continue;
+                const update = if (resolved_version.tag == .npm)
+                    manifest.findBestVersion(resolved_version.value.npm.version, string_buf) orelse continue
+                else
+                    manifest.findByDistTag(resolved_version.value.dist_tag.tag.slice(string_buf)) orelse continue;
+
+                table.printLineSeparator();
+
+                {
+                    // package name
+                    const behavior_str = if (dep.behavior.dev)
+                        " (dev)"
+                    else if (dep.behavior.peer)
+                        " (peer)"
+                    else if (dep.behavior.optional)
+                        " (optional)"
                     else
-                        manifest.findByDistTag(resolved_version.value.dist_tag.tag.slice(string_buf)) orelse continue;
+                        "";
 
-                    table.printLineSeparator();
+                    Output.pretty("{s}", .{table.symbols.verticalEdge()});
+                    for (0..column_left_pad) |_| Output.pretty(" ", .{});
 
-                    {
-                        // package name
-                        const behavior_str = if (dep.behavior.dev)
-                            " (dev)"
-                        else if (dep.behavior.peer)
-                            " (peer)"
-                        else if (dep.behavior.optional)
-                            " (optional)"
-                        else
-                            "";
-
-                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
-                        for (0..column_left_pad) |_| Output.pretty(" ", .{});
-
-                        Output.pretty("{s}<d>{s}<r>", .{ package_name, behavior_str });
-                        for (package_name.len + behavior_str.len..package_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
-                    }
-
-                    {
-                        // current version
-                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
-                        for (0..column_left_pad) |_| Output.pretty(" ", .{});
-
-                        version_writer.print("{}", .{resolution.value.npm.version.fmt(string_buf)}) catch bun.outOfMemory();
-                        Output.pretty("{s}", .{version_buf.items});
-                        for (version_buf.items.len..current_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
-                        version_buf.clearRetainingCapacity();
-                    }
-
-                    {
-                        // update version
-                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
-                        for (0..column_left_pad) |_| Output.pretty(" ", .{});
-
-                        version_writer.print("{}", .{update.version.fmt(manifest.string_buf)}) catch bun.outOfMemory();
-                        Output.pretty("{s}", .{update.version.diffFmt(resolution.value.npm.version, manifest.string_buf, string_buf)});
-                        for (version_buf.items.len..update_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
-                        version_buf.clearRetainingCapacity();
-                    }
-
-                    {
-                        // latest version
-                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
-                        for (0..column_left_pad) |_| Output.pretty(" ", .{});
-
-                        version_writer.print("{}", .{latest.version.fmt(manifest.string_buf)}) catch bun.outOfMemory();
-                        Output.pretty("{s}", .{latest.version.diffFmt(resolution.value.npm.version, manifest.string_buf, string_buf)});
-                        for (version_buf.items.len..latest_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
-                        version_buf.clearRetainingCapacity();
-                    }
-
-                    if (was_filtered) {
-                        Output.pretty("{s}", .{table.symbols.verticalEdge()});
-                        for (0..column_left_pad) |_| Output.pretty(" ", .{});
-
-                        const workspace_name = pkg_names[workspace_pkg_id].slice(string_buf);
-                        Output.pretty("{s}", .{workspace_name});
-
-                        for (workspace_name.len..workspace_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
-                    }
-
-                    Output.pretty("{s}\n", .{table.symbols.verticalEdge()});
+                    Output.pretty("{s}<d>{s}<r>", .{ package_name, behavior_str });
+                    for (package_name.len + behavior_str.len..package_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
                 }
+
+                {
+                    // current version
+                    Output.pretty("{s}", .{table.symbols.verticalEdge()});
+                    for (0..column_left_pad) |_| Output.pretty(" ", .{});
+
+                    version_writer.print("{}", .{resolution.value.npm.version.fmt(string_buf)}) catch bun.outOfMemory();
+                    Output.pretty("{s}", .{version_buf.items});
+                    for (version_buf.items.len..current_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
+                    version_buf.clearRetainingCapacity();
+                }
+
+                {
+                    // update version
+                    Output.pretty("{s}", .{table.symbols.verticalEdge()});
+                    for (0..column_left_pad) |_| Output.pretty(" ", .{});
+
+                    version_writer.print("{}", .{update.version.fmt(manifest.string_buf)}) catch bun.outOfMemory();
+                    Output.pretty("{s}", .{update.version.diffFmt(resolution.value.npm.version, manifest.string_buf, string_buf)});
+                    for (version_buf.items.len..update_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
+                    version_buf.clearRetainingCapacity();
+                }
+
+                {
+                    // latest version
+                    Output.pretty("{s}", .{table.symbols.verticalEdge()});
+                    for (0..column_left_pad) |_| Output.pretty(" ", .{});
+
+                    version_writer.print("{}", .{latest.version.fmt(manifest.string_buf)}) catch bun.outOfMemory();
+                    Output.pretty("{s}", .{latest.version.diffFmt(resolution.value.npm.version, manifest.string_buf, string_buf)});
+                    for (version_buf.items.len..latest_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
+                    version_buf.clearRetainingCapacity();
+                }
+
+                if (was_filtered) {
+                    Output.pretty("{s}", .{table.symbols.verticalEdge()});
+                    for (0..column_left_pad) |_| Output.pretty(" ", .{});
+
+                    const workspace_name = if (item.grouped_workspace_names) |names|
+                        names
+                    else
+                        pkg_names[item.workspace_pkg_id].slice(string_buf);
+                    Output.pretty("{s}", .{workspace_name});
+
+                    for (workspace_name.len..workspace_column_inside_length + column_right_pad) |_| Output.pretty(" ", .{});
+                }
+
+                Output.pretty("{s}\n", .{table.symbols.verticalEdge()});
             }
         }
 
diff --git a/src/cli/update_interactive_command.zig b/src/cli/update_interactive_command.zig
index 8105fa4526..72733b06d5 100644
--- a/src/cli/update_interactive_command.zig
+++ b/src/cli/update_interactive_command.zig
@@ -3,11 +3,6 @@ pub const TerminalHyperlink = struct {
     text: []const u8,
     enabled: bool,
 
-    const Protocol = enum {
-        vscode,
-        cursor,
-    };
-
     pub fn new(link: []const u8, text: []const u8, enabled: bool) TerminalHyperlink {
         return TerminalHyperlink{
             .link = link,
@@ -43,7 +38,79 @@ pub const UpdateInteractiveCommand = struct {
         behavior: Behavior,
         use_latest: bool = false,
         manager: *PackageManager,
+        is_catalog: bool = false,
+        catalog_name: ?[]const u8 = null,
     };
+
+    const CatalogUpdate = struct {
+        version: []const u8,
+        workspace_path: []const u8,
+    };
+
+    // Common utility functions to reduce duplication
+
+    fn buildPackageJsonPath(root_dir: []const u8, workspace_path: []const u8, path_buf: *bun.PathBuffer) []const u8 {
+        if (workspace_path.len > 0) {
+            return bun.path.joinAbsStringBuf(
+                root_dir,
+                path_buf,
+                &[_]string{ workspace_path, "package.json" },
+                .auto,
+            );
+        } else {
+            return bun.path.joinAbsStringBuf(
+                root_dir,
+                path_buf,
+                &[_]string{"package.json"},
+                .auto,
+            );
+        }
+    }
+
+    // Helper to update a catalog entry at a specific path in the package.json AST
+    fn savePackageJson(
+        manager: *PackageManager,
+        package_json: anytype, // MapEntry from WorkspacePackageJSONCache
+        package_json_path: []const u8,
+    ) !void {
+        const preserve_trailing_newline = package_json.*.source.contents.len > 0 and
+            package_json.*.source.contents[package_json.*.source.contents.len - 1] == '\n';
+
+        var buffer_writer = JSPrinter.BufferWriter.init(manager.allocator);
+        try buffer_writer.buffer.list.ensureTotalCapacity(manager.allocator, package_json.*.source.contents.len + 1);
+        buffer_writer.append_newline = preserve_trailing_newline;
+        var package_json_writer = JSPrinter.BufferPrinter.init(buffer_writer);
+
+        _ = JSPrinter.printJSON(
+            @TypeOf(&package_json_writer),
+            &package_json_writer,
+            package_json.*.root,
+            &package_json.*.source,
+            .{
+                .indent = package_json.*.indentation,
+                .mangled_props = null,
+            },
+        ) catch |err| {
+            Output.errGeneric("Failed to serialize package.json: {s}", .{@errorName(err)});
+            return err;
+        };
+
+        const new_package_json_source = try manager.allocator.dupe(u8, package_json_writer.ctx.writtenWithoutTrailingZero());
+        defer manager.allocator.free(new_package_json_source);
+
+        // Write the updated package.json
+        const write_file = std.fs.cwd().createFile(package_json_path, .{}) catch |err| {
+            Output.errGeneric("Failed to write package.json at {s}: {s}", .{ package_json_path, @errorName(err) });
+            return err;
+        };
+        defer write_file.close();
+
+        write_file.writeAll(new_package_json_source) catch |err| {
+            Output.errGeneric("Failed to write package.json at {s}: {s}", .{ package_json_path, @errorName(err) });
+            return err;
+        };
+    }
+
     fn resolveCatalogDependency(manager: *PackageManager, dep: Install.Dependency) ?Install.Dependency.Version {
         return if (dep.version.tag == .catalog) blk: {
             const catalog_dep = manager.lockfile.catalogs.get(
@@ -76,90 +143,185 @@ pub const UpdateInteractiveCommand = struct {
         try updateInteractive(ctx, original_cwd, manager);
     }
 
-    fn updatePackages(
+    const PackageUpdate = struct {
+        name: []const u8,
+        target_version: []const u8,
+        dep_type: []const u8, // "dependencies", "devDependencies", etc.
+        workspace_path: []const u8,
+        original_version: []const u8,
+        package_id: PackageID,
+    };
+
+    fn updatePackageJsonFilesFromUpdates(
         manager: *PackageManager,
-        ctx: Command.Context,
-        updates: []UpdateRequest,
-        original_cwd: string,
+        updates: []const PackageUpdate,
     ) !void {
-        // This function follows the same pattern as updatePackageJSONAndInstallWithManagerWithUpdates
-        // from updatePackageJSONAndInstall.zig
+        // Group updates by workspace
+        var workspace_groups = bun.StringHashMap(std.ArrayList(PackageUpdate)).init(bun.default_allocator);
+        defer {
+            var it = workspace_groups.iterator();
+            while (it.next()) |entry| {
+                entry.value_ptr.deinit();
+            }
+            workspace_groups.deinit();
+        }
 
-        // Load and parse the current package.json
-        var current_package_json = switch (manager.workspace_package_json_cache.getWithPath(
-            manager.allocator,
-            manager.log,
-            manager.original_package_json_path,
-            .{ .guess_indentation = true },
-        )) {
-            .parse_err => |err| {
-                manager.log.print(Output.errorWriter()) catch {};
-                Output.errGeneric("failed to parse package.json \"{s}\": {s}", .{
-                    manager.original_package_json_path,
-                    @errorName(err),
-                });
-                Global.crash();
-            },
-            .read_err => |err| {
-                Output.errGeneric("failed to read package.json \"{s}\": {s}", .{
-                    manager.original_package_json_path,
-                    @errorName(err),
-                });
-                Global.crash();
-            },
-            .entry => |entry| entry,
-        };
+        // Group updates by workspace path
+        for (updates) |update| {
+            const result = try workspace_groups.getOrPut(update.workspace_path);
+            if (!result.found_existing) {
+                result.value_ptr.* = std.ArrayList(PackageUpdate).init(bun.default_allocator);
+            }
+            try result.value_ptr.append(update);
+        }
 
-        const current_package_json_indent = current_package_json.indentation;
-        const preserve_trailing_newline = current_package_json.source.contents.len > 0 and
-            current_package_json.source.contents[current_package_json.source.contents.len - 1] == '\n';
+        // Process each workspace
+        var it = workspace_groups.iterator();
+        while (it.next()) |entry| {
+            const workspace_path = entry.key_ptr.*;
+            const workspace_updates = entry.value_ptr.items;
 
-        // Set update mode
-        manager.to_update = true;
-        manager.update_requests = updates;
+            // Build the package.json path for this workspace
+            const root_dir = FileSystem.instance.top_level_dir;
+            var path_buf: bun.PathBuffer = undefined;
+            const package_json_path = buildPackageJsonPath(root_dir, workspace_path, &path_buf);
 
-        // Edit the package.json with all updates
-        // For interactive mode, we'll edit all as dependencies
-        // TODO: preserve original dependency types
-        var updates_mut = updates;
-        try PackageJSONEditor.edit(
-            manager,
-            &updates_mut,
-            &current_package_json.root,
-            "dependencies",
-            .{
-                .exact_versions = manager.options.enable.exact_versions,
-                .before_install = true,
-            },
-        );
+            // Load and parse the package.json
+            var package_json = switch (manager.workspace_package_json_cache.getWithPath(
+                manager.allocator,
+                manager.log,
+                package_json_path,
+                .{ .guess_indentation = true },
+            )) {
+                .parse_err => |err| {
+                    Output.errGeneric("Failed to parse package.json at {s}: {s}", .{ package_json_path, @errorName(err) });
+                    continue;
+                },
+                .read_err => |err| {
+                    Output.errGeneric("Failed to read package.json at {s}: {s}", .{ package_json_path, @errorName(err) });
+                    continue;
+                },
+                .entry => |package_entry| package_entry,
+            };
 
-        // Serialize the updated package.json
-        var buffer_writer = JSPrinter.BufferWriter.init(manager.allocator);
-        try buffer_writer.buffer.list.ensureTotalCapacity(manager.allocator, current_package_json.source.contents.len + 1);
-        buffer_writer.append_newline = preserve_trailing_newline;
-        var package_json_writer = JSPrinter.BufferPrinter.init(buffer_writer);
+            var modified = false;
 
-        _ = JSPrinter.printJSON(
-            @TypeOf(&package_json_writer),
-            &package_json_writer,
-            current_package_json.root,
-            &current_package_json.source,
-            .{
-                .indent = current_package_json_indent,
-                .mangled_props = null,
-            },
-        ) catch |err| {
-            Output.prettyErrorln("package.json failed to write due to error {s}", .{@errorName(err)});
-            Global.crash();
-        };
+            // Update each package in this workspace's package.json
+            for (workspace_updates) |update| {
+                // Find the package in the correct dependency section
+                if (package_json.root.data == .e_object) {
+                    if (package_json.root.asProperty(update.dep_type)) |section_query| {
+                        if (section_query.expr.data == .e_object) {
+                            const dep_obj = &section_query.expr.data.e_object;
+                            if (section_query.expr.asProperty(update.name)) |version_query| {
+                                if (version_query.expr.data == .e_string) {
+                                    // Get the original version to preserve prefix
+                                    const original_version = version_query.expr.data.e_string.data;
 
-        const new_package_json_source = try manager.allocator.dupe(u8, package_json_writer.ctx.writtenWithoutTrailingZero());
+                                    // Preserve the version prefix from the original
+                                    const version_with_prefix = try preserveVersionPrefix(original_version, update.target_version, manager.allocator);
 
-        // Call installWithManager to perform the installation
-        try manager.installWithManager(ctx, new_package_json_source, original_cwd);
+                                    // Update the version using hash map put
+                                    const new_expr = try Expr.init(
+                                        E.String,
+                                        E.String{ .data = version_with_prefix },
+                                        version_query.expr.loc,
+                                    ).clone(manager.allocator);
+                                    try dep_obj.*.put(manager.allocator, update.name, new_expr);
+                                    modified = true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Write the updated package.json if modified
+            if (modified) {
+                try savePackageJson(manager, &package_json, package_json_path);
+            }
+        }
+    }
+
+    fn updateCatalogDefinitions(
+        manager: *PackageManager,
+        catalog_updates: bun.StringHashMap(CatalogUpdate),
+    ) !void {
+
+        // Group catalog updates by workspace path
+        var workspace_catalog_updates = bun.StringHashMap(std.ArrayList(CatalogUpdateRequest)).init(bun.default_allocator);
+        defer {
+            var it = workspace_catalog_updates.iterator();
+            while (it.next()) |entry| {
+                entry.value_ptr.deinit();
+            }
+            workspace_catalog_updates.deinit();
+        }
+
+        // Group updates by workspace
+        var catalog_it = catalog_updates.iterator();
+        while (catalog_it.next()) |entry| {
+            const catalog_key = entry.key_ptr.*;
+            const update = entry.value_ptr.*;
+
+            const result = try workspace_catalog_updates.getOrPut(update.workspace_path);
+            if (!result.found_existing) {
+                result.value_ptr.* = std.ArrayList(CatalogUpdateRequest).init(bun.default_allocator);
+            }
+
+            // Parse catalog_key (format: "package_name" or "package_name:catalog_name")
+            const colon_index = std.mem.indexOf(u8, catalog_key, ":");
+            const package_name = if (colon_index) |idx| catalog_key[0..idx] else catalog_key;
+            const catalog_name = if (colon_index) |idx| catalog_key[idx + 1 ..] else null;
+
+            try result.value_ptr.append(.{
+                .package_name = package_name,
+                .new_version = update.version,
+                .catalog_name = catalog_name,
+            });
+        }
+
+        // Update catalog definitions for each workspace
+        var workspace_it = workspace_catalog_updates.iterator();
+        while (workspace_it.next()) |workspace_entry| {
+            const workspace_path = workspace_entry.key_ptr.*;
+            const updates_for_workspace = workspace_entry.value_ptr.*;
+
+            // Build the package.json path for this workspace
+            const root_dir = FileSystem.instance.top_level_dir;
+            var path_buf: bun.PathBuffer = undefined;
+            const package_json_path = buildPackageJsonPath(root_dir, workspace_path, &path_buf);
+
+            // Load and parse the package.json properly
+            var package_json = switch (manager.workspace_package_json_cache.getWithPath(
+                manager.allocator,
+                manager.log,
+                package_json_path,
+                .{ .guess_indentation = true },
+            )) {
+                .parse_err => |err| {
+                    Output.errGeneric("Failed to parse package.json at {s}: {s}", .{ package_json_path, @errorName(err) });
+                    continue;
+                },
+                .read_err => |err| {
+                    Output.errGeneric("Failed to read package.json at {s}: {s}", .{ package_json_path, @errorName(err) });
+                    continue;
+                },
+                .entry => |entry| entry,
+            };
+
+            // Use the PackageJSONEditor to update catalogs
+            try editCatalogDefinitions(manager, updates_for_workspace.items, &package_json.root);
+
+            // Save the updated package.json
+            try savePackageJson(manager, &package_json, package_json_path);
+        }
     }
 
     fn updateInteractive(ctx: Command.Context, original_cwd: string, manager: *PackageManager) !void {
+        // make the package manager things think we are actually in root dir
+        // _ = bun.sys.chdir(manager.root_dir.dir, manager.root_dir.dir);
+
         const load_lockfile_result = manager.lockfile.loadFromCwd(
             manager,
             manager.allocator,
@@ -201,151 +363,210 @@ pub const UpdateInteractiveCommand = struct {
             .ok => |ok| ok.lockfile,
         };
 
-        switch (Output.enable_ansi_colors) {
-            inline else => |_| {
-                const workspace_pkg_ids = if (manager.options.filter_patterns.len > 0) blk: {
-                    const filters = manager.options.filter_patterns;
-                    break :blk findMatchingWorkspaces(
-                        bun.default_allocator,
-                        original_cwd,
-                        manager,
-                        filters,
-                    ) catch bun.outOfMemory();
-                } else blk: {
-                    // just the current workspace
-                    const root_pkg_id = manager.root_package_id.get(manager.lockfile, manager.workspace_name_hash);
-                    if (root_pkg_id == invalid_package_id) return;
-                    const ids = bun.default_allocator.alloc(PackageID, 1) catch bun.outOfMemory();
-                    ids[0] = root_pkg_id;
-                    break :blk ids;
-                };
-                defer bun.default_allocator.free(workspace_pkg_ids);
+        const workspace_pkg_ids = if (manager.options.filter_patterns.len > 0) blk: {
+            const filters = manager.options.filter_patterns;
+            break :blk findMatchingWorkspaces(
+                bun.default_allocator,
+                original_cwd,
+                manager,
+                filters,
+            ) catch bun.outOfMemory();
+        } else if (manager.options.do.recursive) blk: {
+            break :blk getAllWorkspaces(bun.default_allocator, manager) catch bun.outOfMemory();
+        } else blk: {
+            const root_pkg_id = manager.root_package_id.get(manager.lockfile, manager.workspace_name_hash);
+            if (root_pkg_id == invalid_package_id) return;
 
-                try OutdatedCommand.updateManifestsIfNecessary(manager, workspace_pkg_ids);
+            const ids = bun.default_allocator.alloc(PackageID, 1) catch bun.outOfMemory();
+            ids[0] = root_pkg_id;
+            break :blk ids;
+        };
+        defer bun.default_allocator.free(workspace_pkg_ids);
 
-                // Get outdated packages
-                const outdated_packages = try getOutdatedPackages(bun.default_allocator, manager, workspace_pkg_ids);
-                defer {
-                    for (outdated_packages) |pkg| {
-                        bun.default_allocator.free(pkg.name);
-                        bun.default_allocator.free(pkg.current_version);
-                        bun.default_allocator.free(pkg.latest_version);
-                        bun.default_allocator.free(pkg.update_version);
-                        bun.default_allocator.free(pkg.workspace_name);
+        try OutdatedCommand.updateManifestsIfNecessary(manager, workspace_pkg_ids);
+
+        // Get outdated packages
+        const outdated_packages = try getOutdatedPackages(bun.default_allocator, manager, workspace_pkg_ids);
+        defer {
+            for (outdated_packages) |pkg| {
+                bun.default_allocator.free(pkg.name);
+                bun.default_allocator.free(pkg.current_version);
+                bun.default_allocator.free(pkg.latest_version);
+                bun.default_allocator.free(pkg.update_version);
+                bun.default_allocator.free(pkg.workspace_name);
+            }
+            bun.default_allocator.free(outdated_packages);
+        }
+
+        if (outdated_packages.len == 0) {
+            // No packages need updating - just exit silently
+            Output.prettyln("<r><green>✓<r> All packages are up to date!", .{});
+            return;
+        }
+
+        // Prompt user to select packages
+        const selected = try promptForUpdates(bun.default_allocator, outdated_packages);
+        defer bun.default_allocator.free(selected);
+
+        // Create package specifier array from selected packages
+        // Group selected packages by workspace
+        var workspace_updates = bun.StringHashMap(std.ArrayList([]const u8)).init(bun.default_allocator);
+        defer {
+            var it = workspace_updates.iterator();
+            while (it.next()) |entry| {
+                entry.value_ptr.deinit();
+            }
+            workspace_updates.deinit();
+        }
+
+        // Track catalog updates separately (catalog_key -> {version, workspace_path})
+        var catalog_updates = bun.StringHashMap(CatalogUpdate).init(bun.default_allocator);
+        defer {
+            var it = catalog_updates.iterator();
+            while (it.next()) |entry| {
+                bun.default_allocator.free(entry.key_ptr.*);
+                bun.default_allocator.free(entry.value_ptr.*.version);
+                bun.default_allocator.free(entry.value_ptr.*.workspace_path);
+            }
+            catalog_updates.deinit();
+        }
+
+        // Collect all package updates with full information
+        var package_updates = std.ArrayList(PackageUpdate).init(bun.default_allocator);
+        defer package_updates.deinit();
+
+        // Process selected packages
+        for (outdated_packages, selected) |pkg, is_selected| {
+            if (!is_selected) continue;
+
+            // Use latest version if requested
+            const target_version = if (pkg.use_latest)
+                pkg.latest_version
+            else
+                pkg.update_version;
+
+            if (strings.eql(pkg.current_version, target_version)) {
+                continue;
+            }
+
+            // For catalog dependencies, we need to collect them separately
+            // to update the catalog definitions in the root or workspace package.json
+            if (pkg.is_catalog) {
+                // Store catalog updates for later processing
+                const catalog_key = if (pkg.catalog_name) |catalog_name|
+                    try std.fmt.allocPrint(bun.default_allocator, "{s}:{s}", .{ pkg.name, catalog_name })
+                else
+                    pkg.name;
+
+                // For catalog dependencies, we always update the root package.json
+                // (or the workspace root where the catalog is defined)
+                const catalog_workspace_path = try bun.default_allocator.dupe(u8, ""); // Always root for now
+
+                try catalog_updates.put(try bun.default_allocator.dupe(u8, catalog_key), .{
+                    .version = try bun.default_allocator.dupe(u8, target_version),
+                    .workspace_path = catalog_workspace_path,
+                });
+                continue;
+            }
+
+            // Get the workspace path for this package
+            const workspace_resolution = manager.lockfile.packages.items(.resolution)[pkg.workspace_pkg_id];
+            const workspace_path = if (workspace_resolution.tag == .workspace)
+                workspace_resolution.value.workspace.slice(manager.lockfile.buffers.string_bytes.items)
+            else
+                ""; // Root workspace
+
+            // Add package update with full information
+            try package_updates.append(.{
+                .name = try bun.default_allocator.dupe(u8, pkg.name),
+                .target_version = try bun.default_allocator.dupe(u8, target_version),
+                .dep_type = try bun.default_allocator.dupe(u8, pkg.dependency_type),
+                .workspace_path = try bun.default_allocator.dupe(u8, workspace_path),
+                .original_version = try bun.default_allocator.dupe(u8, pkg.current_version),
+                .package_id = pkg.package_id,
+            });
+        }
+
+        // Check if we have any updates
+        const has_package_updates = package_updates.items.len > 0;
+        const has_catalog_updates = catalog_updates.count() > 0;
+
+        if (!has_package_updates and !has_catalog_updates) {
+            Output.prettyln("<r><yellow>!</r> No packages selected for update", .{});
+            return;
+        }
+
+        // Actually update the selected packages
+        if (has_package_updates or has_catalog_updates) {
+            if (manager.options.dry_run) {
+                Output.prettyln("\n<r><yellow>Dry run mode: showing what would be updated<r>", .{});
+
+                // In dry-run mode, just show what would be updated without modifying files
+                for (package_updates.items) |update| {
+                    const workspace_display = if (update.workspace_path.len > 0) update.workspace_path else "root";
+                    Output.prettyln("→ Would update {s} to {s} in {s} ({s})", .{ update.name, update.target_version, workspace_display, update.dep_type });
+                }
+
+                if (has_catalog_updates) {
+                    var it = catalog_updates.iterator();
+                    while (it.next()) |entry| {
+                        const catalog_key = entry.key_ptr.*;
+                        const catalog_update = entry.value_ptr.*;
+                        Output.prettyln("→ Would update catalog {s} to {s}", .{ catalog_key, catalog_update.version });
                     }
-                    bun.default_allocator.free(outdated_packages);
                 }
 
-                if (outdated_packages.len == 0) {
-                    // Check if we're using --latest flag
-                    const is_latest_mode = manager.options.do.update_to_latest;
-
-                    if (is_latest_mode) {
-                        Output.prettyln("<r><green>✓<r> All packages are up to date!", .{});
-                    } else {
-                        // Count how many packages have newer versions available
-                        var packages_with_newer_versions: usize = 0;
-
-                        // We need to check all packages for newer versions
-                        for (workspace_pkg_ids) |workspace_pkg_id| {
-                            const pkg_deps = manager.lockfile.packages.items(.dependencies)[workspace_pkg_id];
-                            for (pkg_deps.begin()..pkg_deps.end()) |dep_id| {
-                                const package_id = manager.lockfile.buffers.resolutions.items[dep_id];
-                                if (package_id == invalid_package_id) continue;
-                                const dep = manager.lockfile.buffers.dependencies.items[dep_id];
-                                const resolved_version = resolveCatalogDependency(manager, dep) orelse continue;
-                                if (resolved_version.tag != .npm and resolved_version.tag != .dist_tag) continue;
-                                const resolution = manager.lockfile.packages.items(.resolution)[package_id];
-                                if (resolution.tag != .npm) continue;
-
-                                const package_name = manager.lockfile.packages.items(.name)[package_id].slice(manager.lockfile.buffers.string_bytes.items);
-
-                                var expired = false;
-                                const manifest = manager.manifests.byNameAllowExpired(
-                                    manager,
-                                    manager.scopeForPackageName(package_name),
-                                    package_name,
-                                    &expired,
-                                    .load_from_memory_fallback_to_disk,
-                                ) orelse continue;
-
-                                const latest = manifest.findByDistTag("latest") orelse continue;
-
-                                // Check if current version is less than latest
-                                if (resolution.value.npm.version.order(latest.version, manager.lockfile.buffers.string_bytes.items, manifest.string_buf) == .lt) {
-                                    packages_with_newer_versions += 1;
-                                }
-                            }
-                        }
-
-                        if (packages_with_newer_versions > 0) {
-                            Output.prettyln("<r><green>✓<r> All packages are up to date!\n", .{});
-                            Output.prettyln("<r><d>Excluded {d} package{s} with potentially breaking changes. Run <cyan>`bun update -i --latest`<r><d> to update<r>", .{ packages_with_newer_versions, if (packages_with_newer_versions == 1) "" else "s" });
-                        } else {
-                            Output.prettyln("<r><green>✓<r> All packages are up to date!", .{});
-                        }
-                    }
-                    return;
-                }
-
-                // Prompt user to select packages
-                const selected = try promptForUpdates(bun.default_allocator, outdated_packages);
-                defer bun.default_allocator.free(selected);
-
-                // Create package specifier array from selected packages
-                var package_specifiers = std.ArrayList([]const u8).init(bun.default_allocator);
-                defer package_specifiers.deinit();
-
-                // Create a map to track dependency types for packages
-                var dep_types = bun.StringHashMap([]const u8).init(bun.default_allocator);
-                defer dep_types.deinit();
-
-                for (outdated_packages, selected) |pkg, is_selected| {
-                    if (!is_selected) continue;
-
-                    try dep_types.put(pkg.name, pkg.dependency_type);
-
-                    // Use latest version if user selected it with 'l' key
-                    const target_version = if (pkg.use_latest) pkg.latest_version else pkg.update_version;
-
-                    // Create a full package specifier string for UpdateRequest.parse
-                    const package_specifier = try std.fmt.allocPrint(bun.default_allocator, "{s}@{s}", .{ pkg.name, target_version });
-
-                    try package_specifiers.append(package_specifier);
-                }
-
-                // dep_types will be freed when we exit this scope
-
-                if (package_specifiers.items.len == 0) {
-                    Output.prettyln("<r><yellow>!</r> No packages selected for update", .{});
-                    return;
-                }
-
-                // Parse the package specifiers into UpdateRequests
-                var update_requests_array = UpdateRequest.Array{};
-                const update_requests = UpdateRequest.parse(
-                    bun.default_allocator,
-                    manager,
-                    manager.log,
-                    package_specifiers.items,
-                    &update_requests_array,
-                    .update,
-                );
-
-                // Perform the update
+                Output.prettyln("\n<r><yellow>Dry run complete - no changes made<r>", .{});
+            } else {
                 Output.prettyln("\n<r><cyan>Installing updates...<r>", .{});
                 Output.flush();
 
-                try updatePackages(
-                    manager,
-                    ctx,
-                    update_requests,
-                    original_cwd,
-                );
-            },
+                // Update catalog definitions first if needed
+                if (has_catalog_updates) {
+                    try updateCatalogDefinitions(manager, catalog_updates);
+                }
+
+                // Update all package.json files directly (fast!)
+                if (has_package_updates) {
+                    try updatePackageJsonFilesFromUpdates(manager, package_updates.items);
+                }
+
+                // Get the root package.json from cache (should be updated after our saves)
+                const package_json_contents = manager.root_package_json_file.readToEndAlloc(ctx.allocator, std.math.maxInt(usize)) catch |err| {
+                    if (manager.options.log_level != .silent) {
+                        Output.prettyErrorln("<r><red>{s} reading package.json<r> :(", .{@errorName(err)});
+                        Output.flush();
+                    }
+                    return;
+                };
+                manager.to_update = true;
+
+                // Reset the timer to show actual install time instead of total command time
+                var install_ctx = ctx;
+                install_ctx.start_time = std.time.nanoTimestamp();
+
+                try PackageManager.installWithManager(manager, install_ctx, package_json_contents, manager.root_dir.dir);
+            }
         }
     }
 
+    fn getAllWorkspaces(
+        allocator: std.mem.Allocator,
+        manager: *PackageManager,
+    ) OOM![]const PackageID {
+        const lockfile = manager.lockfile;
+        const packages = lockfile.packages.slice();
+        const pkg_resolutions = packages.items(.resolution);
+
+        var workspace_pkg_ids: std.ArrayListUnmanaged(PackageID) = .{};
+        for (pkg_resolutions, 0..) |resolution, pkg_id| {
+            if (resolution.tag != .workspace and resolution.tag != .root) continue;
+            try workspace_pkg_ids.append(allocator, @intCast(pkg_id));
+        }
+
+        return workspace_pkg_ids.toOwnedSlice(allocator);
+    }
+
     fn findMatchingWorkspaces(
         allocator: std.mem.Allocator,
         original_cwd: string,
@@ -428,6 +649,85 @@ pub const UpdateInteractiveCommand = struct {
         return workspace_pkg_ids.items;
     }
 
+    fn groupCatalogDependencies(
+        allocator: std.mem.Allocator,
+        packages: []OutdatedPackage,
+    ) ![]OutdatedPackage {
+        // Create a map to track catalog dependencies by name
+        var catalog_map = bun.StringHashMap(std.ArrayList(OutdatedPackage)).init(allocator);
+        defer catalog_map.deinit();
+        defer {
+            var iter = catalog_map.iterator();
+            while (iter.next()) |entry| {
+                entry.value_ptr.deinit();
+            }
+        }
+
+        var result = std.ArrayList(OutdatedPackage).init(allocator);
+        defer result.deinit();
+
+        // Group catalog dependencies
+        for (packages) |pkg| {
+            if (pkg.is_catalog) {
+                const entry = try catalog_map.getOrPut(pkg.name);
+                if (!entry.found_existing) {
+                    entry.value_ptr.* = std.ArrayList(OutdatedPackage).init(allocator);
+                }
+                try entry.value_ptr.append(pkg);
+            } else {
+                try result.append(pkg);
+            }
+        }
+
+        // Add grouped catalog dependencies
+        var iter = catalog_map.iterator();
+        while (iter.next()) |entry| {
+            const catalog_packages = entry.value_ptr.items;
+            if (catalog_packages.len > 0) {
+                // Use the first package as the base, but combine workspace names
+                var first = catalog_packages[0];
+
+                // Build combined workspace name
+                var workspace_names = std.ArrayList(u8).init(allocator);
+                defer workspace_names.deinit();
+
+                if (catalog_packages.len > 0) {
+                    if (catalog_packages[0].catalog_name) |catalog_name| {
+                        try workspace_names.appendSlice("catalog:");
+                        try workspace_names.appendSlice(catalog_name);
+                    } else {
+                        try workspace_names.appendSlice("catalog");
+                    }
+                    try workspace_names.appendSlice(" (");
+                } else {
+                    try workspace_names.appendSlice("catalog (");
+                }
+                for (catalog_packages, 0..) |cat_pkg, i| {
+                    if (i > 0) try workspace_names.appendSlice(", ");
+                    try workspace_names.appendSlice(cat_pkg.workspace_name);
+                }
+                try workspace_names.append(')');
+
+                // Free the old workspace_name and replace with combined
+                allocator.free(first.workspace_name);
+                first.workspace_name = try workspace_names.toOwnedSlice();
+
+                try result.append(first);
+
+                // Free the other catalog packages
+                for (catalog_packages[1..]) |cat_pkg| {
+                    allocator.free(cat_pkg.name);
+                    allocator.free(cat_pkg.current_version);
+                    allocator.free(cat_pkg.latest_version);
+                    allocator.free(cat_pkg.update_version);
+                    allocator.free(cat_pkg.workspace_name);
+                }
+            }
+        }
+
+        return result.toOwnedSlice();
+    }
+
     fn getOutdatedPackages(
         allocator: std.mem.Allocator,
         manager: *PackageManager,
@@ -472,27 +772,30 @@ pub const UpdateInteractiveCommand = struct {
 
                 const latest = manifest.findByDistTag("latest") orelse continue;
 
-                const update_version = if (manager.options.do.update_to_latest)
-                    latest
-                else if (resolved_version.tag == .npm)
-                    manifest.findBestVersion(resolved_version.value.npm.version, string_buf) orelse continue
+                // In interactive mode, show the constrained update version as "Target"
+                // but always include packages (don't filter out breaking changes)
+                const update_version = if (resolved_version.tag == .npm)
+                    manifest.findBestVersion(resolved_version.value.npm.version, string_buf) orelse latest
                 else
-                    manifest.findByDistTag(resolved_version.value.dist_tag.tag.slice(string_buf)) orelse continue;
+                    manifest.findByDistTag(resolved_version.value.dist_tag.tag.slice(string_buf)) orelse latest;
 
-                // Skip if current version is already the latest
-                if (resolution.value.npm.version.order(latest.version, string_buf, manifest.string_buf) != .lt) continue;
-
-                // Skip if update version is the same as current version
-                // Note: Current version is in lockfile's string_buf, update version is in manifest's string_buf
+                // Skip only if both the constrained update AND the latest version are the same as current
+                // This ensures we show packages where latest is newer even if constrained update isn't
                 const current_ver = resolution.value.npm.version;
                 const update_ver = update_version.version;
+                const latest_ver = latest.version;
 
-                // Compare the actual version numbers
-                if (current_ver.major == update_ver.major and
+                const update_is_same = (current_ver.major == update_ver.major and
                     current_ver.minor == update_ver.minor and
                     current_ver.patch == update_ver.patch and
-                    current_ver.tag.eql(update_ver.tag))
-                {
+                    current_ver.tag.eql(update_ver.tag));
+
+                const latest_is_same = (current_ver.major == latest_ver.major and
+                    current_ver.minor == latest_ver.minor and
+                    current_ver.patch == latest_ver.patch and
+                    current_ver.tag.eql(latest_ver.tag));
+
+                if (update_is_same and latest_is_same) {
                     continue;
                 }
 
@@ -520,6 +823,13 @@ pub const UpdateInteractiveCommand = struct {
                 else
                     "";
 
+                const catalog_name_str = if (dep.version.tag == .catalog)
+                    dep.version.value.catalog.slice(string_buf)
+                else
+                    "";
+
+                const catalog_name: ?[]const u8 = if (catalog_name_str.len > 0) try allocator.dupe(u8, catalog_name_str) else null;
+
                 try outdated_packages.append(.{
                     .name = try allocator.dupe(u8, name_slice),
                     .current_version = try allocator.dupe(u8, current_version_buf),
@@ -532,14 +842,20 @@ pub const UpdateInteractiveCommand = struct {
                     .workspace_name = try allocator.dupe(u8, workspace_name),
                     .behavior = dep.behavior,
                     .manager = manager,
+                    .is_catalog = dep.version.tag == .catalog,
+                    .catalog_name = catalog_name,
+                    .use_latest = manager.options.do.update_to_latest, // default to --latest flag value
                 });
             }
         }
 
         const result = try outdated_packages.toOwnedSlice();
 
+        // Group catalog dependencies
+        const grouped_result = try groupCatalogDependencies(allocator, result);
+
         // Sort packages: dependencies first, then devDependencies, etc.
-        std.sort.pdq(OutdatedPackage, result, {}, struct {
+        std.sort.pdq(OutdatedPackage, grouped_result, {}, struct {
             fn lessThan(_: void, a: OutdatedPackage, b: OutdatedPackage) bool {
                 // First sort by dependency type
                 const a_priority = depTypePriority(a.dependency_type);
@@ -559,7 +875,7 @@ pub const UpdateInteractiveCommand = struct {
             }
         }.lessThan);
 
-        return result;
+        return grouped_result;
     }
 
     const ColumnWidths = struct {
@@ -567,6 +883,8 @@ pub const UpdateInteractiveCommand = struct {
         current: usize,
         target: usize,
         latest: usize,
+        workspace: usize,
+        show_workspace: bool,
     };
 
     const MultiSelectState = struct {
@@ -578,6 +896,8 @@ pub const UpdateInteractiveCommand = struct {
         max_current_len: usize = 0,
         max_update_len: usize = 0,
         max_latest_len: usize = 0,
+        max_workspace_len: usize = 0,
+        show_workspace: bool = false,
     };
 
     fn calculateColumnWidths(packages: []OutdatedPackage) ColumnWidths {
@@ -586,6 +906,8 @@ pub const UpdateInteractiveCommand = struct {
         var max_current_len: usize = "Current".len;
         var max_target_len: usize = "Target".len;
         var max_latest_len: usize = "Latest".len;
+        var max_workspace_len: usize = "Workspace".len;
+        var has_workspaces = false;
 
         for (packages) |pkg| {
             // Include dev tag length in max calculation
@@ -602,6 +924,12 @@ pub const UpdateInteractiveCommand = struct {
             max_current_len = @max(max_current_len, pkg.current_version.len);
             max_target_len = @max(max_target_len, pkg.update_version.len);
             max_latest_len = @max(max_latest_len, pkg.latest_version.len);
+            max_workspace_len = @max(max_workspace_len, pkg.workspace_name.len);
+
+            // Check if we have any non-empty workspace names
+            if (pkg.workspace_name.len > 0) {
+                has_workspaces = true;
+            }
         }
 
         // Use natural widths without any limits
@@ -610,6 +938,8 @@ pub const UpdateInteractiveCommand = struct {
             .current = max_current_len,
             .target = max_target_len,
             .latest = max_latest_len,
+            .workspace = max_workspace_len,
+            .show_workspace = has_workspaces,
         };
     }
 
@@ -633,6 +963,8 @@ pub const UpdateInteractiveCommand = struct {
             .max_current_len = columns.current,
             .max_update_len = columns.target,
             .max_latest_len = columns.latest,
+            .max_workspace_len = columns.workspace,
+            .show_workspace = columns.show_workspace,
         };
 
         // Set raw mode
@@ -776,6 +1108,13 @@ pub const UpdateInteractiveCommand = struct {
                         Output.print(" ", .{});
                     }
                     Output.print("Latest", .{});
+                    if (state.show_workspace) {
+                        j = 0;
+                        while (j < state.max_latest_len - "Latest".len + 2) : (j += 1) {
+                            Output.print(" ", .{});
+                        }
+                        Output.print("Workspace", .{});
+                    }
                     Output.print("\x1B[0K\n", .{});
                     displayed_lines += 1;
                     current_dep_type = pkg.dependency_type;
@@ -1023,6 +1362,17 @@ pub const UpdateInteractiveCommand = struct {
                     }
                 }
 
+                // Workspace column
+                if (state.show_workspace) {
+                    const latest_width: usize = pkg.latest_version.len;
+                    const latest_padding = if (latest_width >= state.max_latest_len) 0 else state.max_latest_len - latest_width;
+                    j = 0;
+                    while (j < latest_padding + 2) : (j += 1) {
+                        Output.print(" ", .{});
+                    }
+                    Output.pretty("<r><d>{s}<r>", .{pkg.workspace_name});
+                }
+
                 Output.print("\x1B[0K\n", .{});
                 displayed_lines += 1;
             }
@@ -1039,22 +1389,43 @@ pub const UpdateInteractiveCommand = struct {
                 3, 4 => return error.EndOfStream, // ctrl+c, ctrl+d
                 ' ' => {
                     state.selected[state.cursor] = !state.selected[state.cursor];
+                    // if the package only has a latest version, then we should toggle the latest version instead of update
+                    if (strings.eql(state.packages[state.cursor].current_version, state.packages[state.cursor].update_version)) {
+                        state.packages[state.cursor].use_latest = true;
+                    }
+                    state.toggle_all = false;
                     // Don't move cursor on space - let user manually navigate
                 },
                 'a', 'A' => {
                     @memset(state.selected, true);
+                    state.toggle_all = true; // Mark that 'a' was used
                 },
                 'n', 'N' => {
                     @memset(state.selected, false);
+                    state.toggle_all = false; // Reset toggle_all mode
                 },
                 'i', 'I' => {
                     // Invert selection
                     for (state.selected) |*sel| {
                         sel.* = !sel.*;
                     }
+                    state.toggle_all = false; // Reset toggle_all mode
                 },
                 'l', 'L' => {
-                    state.packages[state.cursor].use_latest = !state.packages[state.cursor].use_latest;
+                    // Only affect all packages if 'a' (select all) was used
+                    // Otherwise, just toggle the current cursor package
+                    if (state.toggle_all) {
+                        // All packages were selected with 'a', so toggle latest for all selected packages
+                        const new_latest_state = !state.packages[state.cursor].use_latest;
+                        for (state.selected, state.packages) |sel, *pkg| {
+                            if (sel) {
+                                pkg.use_latest = new_latest_state;
+                            }
+                        }
+                    } else {
+                        // Individual selection mode, just toggle current cursor package
+                        state.packages[state.cursor].use_latest = !state.packages[state.cursor].use_latest;
+                    }
                 },
                 'j' => {
                     if (state.cursor < state.packages.len - 1) {
@@ -1062,6 +1433,7 @@ pub const UpdateInteractiveCommand = struct {
                     } else {
                         state.cursor = 0;
                     }
+                    state.toggle_all = false;
                 },
                 'k' => {
                     if (state.cursor > 0) {
@@ -1069,6 +1441,7 @@ pub const UpdateInteractiveCommand = struct {
                     } else {
                         state.cursor = state.packages.len - 1;
                     }
+                    state.toggle_all = false;
                 },
                 27 => { // escape sequence
                     const seq = std.io.getStdIn().reader().readByte() catch continue;
@@ -1092,8 +1465,11 @@ pub const UpdateInteractiveCommand = struct {
                             else => {},
                         }
                     }
+                    state.toggle_all = false;
+                },
+                else => {
+                    state.toggle_all = false;
                 },
-                else => {},
             }
         }
     }
@@ -1103,6 +1479,185 @@ extern fn Bun__ttySetMode(fd: c_int, mode: c_int) c_int;
 
 const string = []const u8;
 
+pub const CatalogUpdateRequest = struct {
+    package_name: string,
+    new_version: string,
+    catalog_name: ?string = null,
+};
+
+/// Edit catalog definitions in package.json
+pub fn editCatalogDefinitions(
+    manager: *PackageManager,
+    updates: []CatalogUpdateRequest,
+    current_package_json: *Expr,
+) !void {
+    // 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
+    Expr.Disabler.disable();
+    defer Expr.Disabler.enable();
+
+    const allocator = manager.allocator;
+
+    for (updates) |update| {
+        if (update.catalog_name) |catalog_name| {
+            try updateNamedCatalog(allocator, current_package_json, catalog_name, update.package_name, update.new_version);
+        } else {
+            try updateDefaultCatalog(allocator, current_package_json, update.package_name, update.new_version);
+        }
+    }
+}
+
+fn updateDefaultCatalog(
+    allocator: std.mem.Allocator,
+    package_json: *Expr,
+    package_name: string,
+    new_version: string,
+) !void {
+    // Get or create the catalog object
+    // First check if catalog is under workspaces.catalog
+    var catalog_obj = brk: {
+        if (package_json.asProperty("workspaces")) |workspaces_query| {
+            if (workspaces_query.expr.data == .e_object) {
+                if (workspaces_query.expr.asProperty("catalog")) |catalog_query| {
+                    if (catalog_query.expr.data == .e_object)
+                        break :brk catalog_query.expr.data.e_object.*;
+                }
+            }
+        }
+        // Fallback to root-level catalog
+        if (package_json.asProperty("catalog")) |catalog_query| {
+            if (catalog_query.expr.data == .e_object)
+                break :brk catalog_query.expr.data.e_object.*;
+        }
+        break :brk E.Object{};
+    };
+
+    // Get original version to preserve prefix if it exists
+    var version_with_prefix = new_version;
+    if (catalog_obj.get(package_name)) |existing_prop| {
+        if (existing_prop.data == .e_string) {
+            const original_version = existing_prop.data.e_string.data;
+            version_with_prefix = try preserveVersionPrefix(original_version, new_version, allocator);
+        }
+    }
+
+    // Update or add the package version
+    const new_expr = Expr.allocate(allocator, E.String, E.String{ .data = version_with_prefix }, logger.Loc.Empty);
+    try catalog_obj.put(allocator, package_name, new_expr);
+
+    // Check if we need to update under workspaces.catalog or root-level catalog
+    if (package_json.asProperty("workspaces")) |workspaces_query| {
+        if (workspaces_query.expr.data == .e_object) {
+            if (workspaces_query.expr.asProperty("catalog")) |_| {
+                // Update under workspaces.catalog
+                try workspaces_query.expr.data.e_object.put(
+                    allocator,
+                    "catalog",
+                    Expr.allocate(allocator, E.Object, catalog_obj, logger.Loc.Empty),
+                );
+                return;
+            }
+        }
+    }
+
+    // Otherwise update at root level
+    try package_json.data.e_object.put(
+        allocator,
+        "catalog",
+        Expr.allocate(allocator, E.Object, catalog_obj, logger.Loc.Empty),
+    );
+}
+
+fn updateNamedCatalog(
+    allocator: std.mem.Allocator,
+    package_json: *Expr,
+    catalog_name: string,
+    package_name: string,
+    new_version: string,
+) !void {
+
+    // Get or create the catalogs object
+    // First check if catalogs is under workspaces.catalogs (newer structure)
+    var catalogs_obj = brk: {
+        if (package_json.asProperty("workspaces")) |workspaces_query| {
+            if (workspaces_query.expr.data == .e_object) {
+                if (workspaces_query.expr.asProperty("catalogs")) |catalogs_query| {
+                    if (catalogs_query.expr.data == .e_object)
+                        break :brk catalogs_query.expr.data.e_object.*;
+                }
+            }
+        }
+        // Fallback to root-level catalogs
+        if (package_json.asProperty("catalogs")) |catalogs_query| {
+            if (catalogs_query.expr.data == .e_object)
+                break :brk catalogs_query.expr.data.e_object.*;
+        }
+        break :brk E.Object{};
+    };
+
+    // Get or create the specific catalog
+    var catalog_obj = brk: {
+        if (catalogs_obj.get(catalog_name)) |catalog_query| {
+            if (catalog_query.data == .e_object)
+                break :brk catalog_query.data.e_object.*;
+        }
+        break :brk E.Object{};
+    };
+
+    // Get original version to preserve prefix if it exists
+    var version_with_prefix = new_version;
+    if (catalog_obj.get(package_name)) |existing_prop| {
+        if (existing_prop.data == .e_string) {
+            const original_version = existing_prop.data.e_string.data;
+            version_with_prefix = try preserveVersionPrefix(original_version, new_version, allocator);
+        }
+    }
+
+    // Update or add the package version
+    const new_expr = Expr.allocate(allocator, E.String, E.String{ .data = version_with_prefix }, logger.Loc.Empty);
+    try catalog_obj.put(allocator, package_name, new_expr);
+
+    // Update the catalog in catalogs object
+    try catalogs_obj.put(
+        allocator,
+        catalog_name,
+        Expr.allocate(allocator, E.Object, catalog_obj, logger.Loc.Empty),
+    );
+
+    // Check if we need to update under workspaces.catalogs or root-level catalogs
+    if (package_json.asProperty("workspaces")) |workspaces_query| {
+        if (workspaces_query.expr.data == .e_object) {
+            if (workspaces_query.expr.asProperty("catalogs")) |_| {
+                // Update under workspaces.catalogs
+                try workspaces_query.expr.data.e_object.put(
+                    allocator,
+                    "catalogs",
+                    Expr.allocate(allocator, E.Object, catalogs_obj, logger.Loc.Empty),
+                );
+                return;
+            }
+        }
+    }
+
+    // Otherwise update at root level
+    try package_json.data.e_object.put(
+        allocator,
+        "catalogs",
+        Expr.allocate(allocator, E.Object, catalogs_obj, logger.Loc.Empty),
+    );
+}
+
+fn preserveVersionPrefix(original_version: string, new_version: string, allocator: std.mem.Allocator) !string {
+    if (original_version.len > 0) {
+        const first_char = original_version[0];
+        if (first_char == '^' or first_char == '~' or first_char == '>' or first_char == '<' or first_char == '=') {
+            return try std.fmt.allocPrint(allocator, "{c}{s}", .{ first_char, new_version });
+        }
+    }
+    return try allocator.dupe(u8, new_version);
+}
+
 const std = @import("std");
 
 const bun = @import("bun");
@@ -1113,12 +1668,18 @@ const OOM = bun.OOM;
 const Output = bun.Output;
 const PathBuffer = bun.PathBuffer;
 const glob = bun.glob;
+const logger = bun.logger;
 const path = bun.path;
 const strings = bun.strings;
 const FileSystem = bun.fs.FileSystem;
 
 const Semver = bun.Semver;
 const SlicedString = Semver.SlicedString;
+const String = Semver.String;
+
+const JSAst = bun.ast;
+const E = JSAst.E;
+const Expr = JSAst.Expr;
 
 const Command = bun.cli.Command;
 const OutdatedCommand = bun.cli.OutdatedCommand;
@@ -1131,5 +1692,4 @@ const Behavior = Install.Dependency.Behavior;
 
 const PackageManager = Install.PackageManager;
 const PackageJSONEditor = PackageManager.PackageJSONEditor;
-const UpdateRequest = PackageManager.UpdateRequest;
 const WorkspaceFilter = PackageManager.WorkspaceFilter;
diff --git a/src/install/PackageManager.zig b/src/install/PackageManager.zig
index fcb33f68ed..eab0caf21f 100644
--- a/src/install/PackageManager.zig
+++ b/src/install/PackageManager.zig
@@ -178,6 +178,7 @@ pub const Subcommand = enum {
         return switch (this) {
             .outdated => true,
             .install => true,
+            .update => true,
             // .pack => true,
             // .add => true,
             else => false,
diff --git a/src/install/PackageManager/CommandLineArguments.zig b/src/install/PackageManager/CommandLineArguments.zig
index 84ed4f8d10..6ca71a5ca0 100644
--- a/src/install/PackageManager/CommandLineArguments.zig
+++ b/src/install/PackageManager/CommandLineArguments.zig
@@ -67,7 +67,9 @@ pub const install_params: []const ParamType = &(shared_params ++ [_]ParamType{
 pub const update_params: []const ParamType = &(shared_params ++ [_]ParamType{
     clap.parseParam("--latest                              Update packages to their latest versions") catch unreachable,
     clap.parseParam("-i, --interactive                     Show an interactive list of outdated packages to select for update") catch unreachable,
-    clap.parseParam("<POS> ...                         \"name\" of packages to update") catch unreachable,
+    clap.parseParam("--filter <STR>...                     Update packages for the matching workspaces") catch unreachable,
+    clap.parseParam("-r, --recursive                       Update packages in all workspaces") catch unreachable,
+    clap.parseParam("<POS> ...                             \"name\" of packages to update") catch unreachable,
 });
 
 pub const pm_params: []const ParamType = &(shared_params ++ [_]ParamType{
@@ -123,7 +125,8 @@ const patch_commit_params: []const ParamType = &(shared_params ++ [_]ParamType{
 
 const outdated_params: []const ParamType = &(shared_params ++ [_]ParamType{
     // clap.parseParam("--json                                 Output outdated information in JSON format") catch unreachable,
-    clap.parseParam("-F, --filter <STR>...                        Display outdated dependencies for each matching workspace") catch unreachable,
+    clap.parseParam("-F, --filter <STR>...                  Display outdated dependencies for each matching workspace") catch unreachable,
+    clap.parseParam("-r, --recursive                        Check outdated packages in all workspaces") catch unreachable,
     clap.parseParam("<POS> ...                              Package patterns to filter by") catch unreachable,
 });
 
@@ -189,6 +192,7 @@ no_summary: bool = false,
 latest: bool = false,
 interactive: bool = false,
 json_output: bool = false,
+recursive: bool = false,
 filters: []const string = &.{},
 
 pack_destination: string = "",
@@ -785,6 +789,7 @@ pub fn parse(allocator: std.mem.Allocator, comptime subcommand: Subcommand) !Com
     if (comptime subcommand == .outdated) {
         // fake --dry-run, we don't actually resolve+clean the lockfile
         cli.dry_run = true;
+        cli.recursive = args.flag("--recursive");
         // cli.json_output = args.flag("--json");
     }
 
@@ -898,6 +903,7 @@ pub fn parse(allocator: std.mem.Allocator, comptime subcommand: Subcommand) !Com
     if (comptime subcommand == .update) {
         cli.latest = args.flag("--latest");
         cli.interactive = args.flag("--interactive");
+        cli.recursive = args.flag("--recursive");
     }
 
     const specified_backend: ?PackageInstall.Method = brk: {
diff --git a/src/install/PackageManager/PackageJSONEditor.zig b/src/install/PackageManager/PackageJSONEditor.zig
index 67eae120ce..43f0225a34 100644
--- a/src/install/PackageManager/PackageJSONEditor.zig
+++ b/src/install/PackageManager/PackageJSONEditor.zig
@@ -5,6 +5,17 @@ const dependency_groups = &.{
     .{ "peerDependencies", .{ .peer = true } },
 };
 
+fn resolveCatalogDependency(manager: *PackageManager, dep: Dependency) ?Dependency.Version {
+    return if (dep.version.tag == .catalog) blk: {
+        const catalog_dep = manager.lockfile.catalogs.get(
+            manager.lockfile,
+            dep.version.value.catalog,
+            dep.name,
+        ) orelse return null;
+        break :blk catalog_dep.version;
+    } else dep.version;
+}
+
 pub const EditOptions = struct {
     exact_versions: bool = false,
     add_trusted_dependencies: bool = false,
@@ -217,8 +228,8 @@ pub fn editUpdateNoArgs(
                         const version_literal = try value.asStringCloned(allocator) orelse bun.outOfMemory();
                         var tag = Dependency.Version.Tag.infer(version_literal);
 
-                        // only updating dependencies with npm versions, and dist-tags if `--latest`.
-                        if (tag != .npm and (tag != .dist_tag or !manager.options.do.update_to_latest)) continue;
+                        // only updating dependencies with npm versions, dist-tags if `--latest`, and catalog versions.
+                        if (tag != .npm and (tag != .dist_tag or !manager.options.do.update_to_latest) and tag != .catalog) continue;
 
                         var alias_at_index: ?usize = null;
                         if (strings.hasPrefixComptime(strings.trim(version_literal, &strings.whitespace_chars), "npm:")) {
@@ -226,7 +237,7 @@ pub fn editUpdateNoArgs(
                             // e.g. "dep": "npm:@foo/bar@1.2.3"
                             if (strings.lastIndexOfChar(version_literal, '@')) |at_index| {
                                 tag = Dependency.Version.Tag.infer(version_literal[at_index + 1 ..]);
-                                if (tag != .npm and (tag != .dist_tag or !manager.options.do.update_to_latest)) continue;
+                                if (tag != .npm and (tag != .dist_tag or !manager.options.do.update_to_latest) and tag != .catalog) continue;
                                 alias_at_index = at_index;
                             }
                         }
@@ -291,7 +302,8 @@ pub fn editUpdateNoArgs(
                                     const workspace_dep_name = workspace_dep.name.slice(string_buf);
                                     if (!strings.eqlLong(workspace_dep_name, dep_name, true)) continue;
 
-                                    if (workspace_dep.version.npm()) |npm_version| {
+                                    const resolved_version = resolveCatalogDependency(manager, workspace_dep) orelse workspace_dep.version;
+                                    if (resolved_version.npm()) |npm_version| {
                                         // It's possible we inserted a dependency that won't update (version is an exact version).
                                         // If we find one, skip to keep the original version literal.
                                         if (!manager.options.do.update_to_latest and npm_version.version.isExact()) break :updated;
diff --git a/src/install/PackageManager/PackageManagerOptions.zig b/src/install/PackageManager/PackageManagerOptions.zig
index 26c023c1b2..98cf61610d 100644
--- a/src/install/PackageManager/PackageManagerOptions.zig
+++ b/src/install/PackageManager/PackageManagerOptions.zig
@@ -568,6 +568,7 @@ pub fn load(
         }
 
         this.do.update_to_latest = cli.latest;
+        this.do.recursive = cli.recursive;
 
         if (cli.positionals.len > 0) {
             this.positionals = cli.positionals;
@@ -666,7 +667,8 @@ pub const Do = packed struct(u16) {
     trust_dependencies_from_args: bool = false,
     update_to_latest: bool = false,
     analyze: bool = false,
-    _: u4 = 0,
+    recursive: bool = false,
+    _: u3 = 0,
 };
 
 pub const Enable = packed struct(u16) {
diff --git a/src/install/PackageManager/updatePackageJSONAndInstall.zig b/src/install/PackageManager/updatePackageJSONAndInstall.zig
index c603555ec0..e4288b9f11 100644
--- a/src/install/PackageManager/updatePackageJSONAndInstall.zig
+++ b/src/install/PackageManager/updatePackageJSONAndInstall.zig
@@ -22,6 +22,7 @@ pub fn updatePackageJSONAndInstallWithManager(
 
                 Global.exit(0);
             },
+            .update => {},
             else => {},
         }
     }
diff --git a/test/cli/install/bun-install-registry.test.ts b/test/cli/install/bun-install-registry.test.ts
index 0310cde1f2..05b9823d86 100644
--- a/test/cli/install/bun-install-registry.test.ts
+++ b/test/cli/install/bun-install-registry.test.ts
@@ -8484,6 +8484,81 @@ describe("outdated", () => {
     expect(out).toContain("no-deps");
     expect(out).toContain("a-dep");
   });
+
+  test("--recursive flag for outdated", async () => {
+    // First verify the flag appears in help
+    const {
+      stdout: helpOut,
+      stderr: helpErr,
+      exited: helpExited,
+    } = spawn({
+      cmd: [bunExe(), "outdated", "--help"],
+      cwd: packageDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env,
+    });
+
+    const help = (await new Response(helpOut).text()) + (await new Response(helpErr).text());
+    expect(await helpExited).toBe(0);
+    expect(help).toContain("--recursive");
+    expect(help).toContain("-r");
+
+    // Setup workspace
+    await setupWorkspace();
+    await runBunInstall(env, packageDir);
+
+    // Test --recursive shows all workspaces
+    const out = await runBunOutdated(env, packageDir, "--recursive");
+    expect(out).toContain("no-deps");
+    expect(out).toContain("a-dep");
+    expect(out).toContain("prereleases-1");
+  });
+
+  test("catalog grouping with multiple workspaces", async () => {
+    await Promise.all([
+      write(
+        packageJson,
+        JSON.stringify({
+          name: "root",
+          workspaces: ["packages/*"],
+          catalog: {
+            "no-deps": "1.0.0",
+          },
+        }),
+      ),
+      write(
+        join(packageDir, "packages", "workspace-a", "package.json"),
+        JSON.stringify({
+          name: "workspace-a",
+          dependencies: {
+            "no-deps": "catalog:",
+          },
+        }),
+      ),
+      write(
+        join(packageDir, "packages", "workspace-b", "package.json"),
+        JSON.stringify({
+          name: "workspace-b",
+          dependencies: {
+            "no-deps": "catalog:",
+          },
+        }),
+      ),
+    ]);
+
+    await runBunInstall(env, packageDir);
+
+    // Test with filter to show workspace column and grouping
+    const out = await runBunOutdated(env, packageDir, "--filter", "*");
+    // Should show all workspaces with catalog entries
+    expect(out).toContain("workspace-a");
+    expect(out).toContain("workspace-b");
+    expect(out).toContain("no-deps");
+
+    // The catalog grouping should show which workspaces use it
+    expect(out).toMatch(/catalog.*workspace-a.*workspace-b|workspace-b.*workspace-a/);
+  });
 });
 
 // TODO: setup registry to run across multiple test files, then move this and a few other describe
diff --git a/test/cli/install/bun-update.test.ts b/test/cli/install/bun-update.test.ts
index 15a8bd28e8..9443557bb1 100644
--- a/test/cli/install/bun-update.test.ts
+++ b/test/cli/install/bun-update.test.ts
@@ -1,6 +1,6 @@
 import { file, spawn } from "bun";
 import { afterAll, afterEach, beforeAll, beforeEach, expect, it } from "bun:test";
-import { access, readFile, rm, writeFile } from "fs/promises";
+import { access, mkdir, readFile, rm, writeFile } from "fs/promises";
 import { bunExe, bunEnv as env, readdirSorted, toBeValidBin, toHaveBins } from "harness";
 import { join } from "path";
 import {
@@ -369,3 +369,113 @@ it("lockfile should not be modified when there are no version changes, issue#588
   // Assert we actually made a request to the registry for each update
   expect(urls).toHaveLength(count);
 });
+
+it("should support catalog versions in update", async () => {
+  const urls: string[] = [];
+  setHandler(dummyRegistry(urls));
+
+  // Create a monorepo with catalog
+  await writeFile(
+    join(package_dir, "package.json"),
+    JSON.stringify({
+      name: "root",
+      catalog: {
+        "no-deps": "^1.0.0",
+      },
+      workspaces: ["packages/*"],
+    }),
+  );
+
+  await mkdir(join(package_dir, "packages", "workspace-a"), { recursive: true });
+  await writeFile(
+    join(package_dir, "packages", "workspace-a", "package.json"),
+    JSON.stringify({
+      name: "workspace-a",
+      dependencies: {
+        "no-deps": "catalog:",
+      },
+    }),
+  );
+
+  // Test that update works with catalog dependencies
+  const { stdout, stderr, exited } = spawn({
+    cmd: [bunExe(), "update", "--dry-run"],
+    cwd: join(package_dir, "packages", "workspace-a"),
+    stdout: "pipe",
+    stderr: "pipe",
+    env,
+  });
+
+  const err = await new Response(stderr).text();
+  const out = await new Response(stdout).text();
+
+  // Should not crash with catalog dependencies
+  expect(err).not.toContain("panic");
+  expect(err).not.toContain("segfault");
+
+  // Verify catalog reference is preserved in package.json
+  const pkg = await file(join(package_dir, "packages", "workspace-a", "package.json")).json();
+  expect(pkg.dependencies["no-deps"]).toBe("catalog:");
+});
+
+it("should support --recursive flag", async () => {
+  // First verify the flag appears in help
+  const {
+    stdout: helpOut,
+    stderr: helpErr,
+    exited: helpExited,
+  } = spawn({
+    cmd: [bunExe(), "update", "--help"],
+    cwd: package_dir,
+    stdout: "pipe",
+    stderr: "pipe",
+    env,
+  });
+
+  const help = (await new Response(helpOut).text()) + (await new Response(helpErr).text());
+  expect(await helpExited).toBe(0);
+  expect(help).toContain("--recursive");
+  expect(help).toContain("-r");
+
+  // Now test that --recursive actually works
+  await writeFile(
+    join(package_dir, "package.json"),
+    JSON.stringify({
+      name: "root",
+      workspaces: ["packages/*"],
+      dependencies: {
+        "no-deps": "^1.0.0",
+      },
+    }),
+  );
+
+  await mkdir(join(package_dir, "packages", "pkg1"), { recursive: true });
+  await writeFile(
+    join(package_dir, "packages", "pkg1", "package.json"),
+    JSON.stringify({
+      name: "pkg1",
+      dependencies: {
+        "no-deps": "^1.0.0",
+      },
+    }),
+  );
+
+  // Test recursive update (might fail without lockfile, but shouldn't crash)
+  const { stdout, stderr, exited } = spawn({
+    cmd: [bunExe(), "update", "--recursive", "--dry-run"],
+    cwd: package_dir,
+    stdout: "pipe",
+    stderr: "pipe",
+    env,
+  });
+
+  const out = await new Response(stdout).text();
+  const err = await new Response(stderr).text();
+
+  // Should not crash
+  expect(err).not.toContain("panic");
+  expect(err).not.toContain("segfault");
+
+  // Should recognize the flag (either process workspaces or show error about missing lockfile)
+  expect(out + err).toMatch(/bun update|missing lockfile|nothing to update/);
+});
diff --git a/test/cli/update_interactive_formatting.test.ts b/test/cli/update_interactive_formatting.test.ts
index 7b28c7318f..8e54570781 100644
--- a/test/cli/update_interactive_formatting.test.ts
+++ b/test/cli/update_interactive_formatting.test.ts
@@ -1,8 +1,21 @@
-import { describe, expect, it } from "bun:test";
-import { bunEnv, bunExe, tempDirWithFiles } from "harness";
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { bunEnv, bunExe, tempDirWithFiles, VerdaccioRegistry } from "harness";
 import { join } from "path";
 
-describe("bun update --interactive formatting", () => {
+let registry: VerdaccioRegistry;
+let registryUrl: string;
+
+beforeAll(async () => {
+  registry = new VerdaccioRegistry();
+  registryUrl = registry.registryUrl();
+  await registry.start();
+});
+
+afterAll(() => {
+  registry.stop();
+});
+
+describe("bun update --interactive", () => {
   it("should handle package names of unusual lengths", async () => {
     const dir = tempDirWithFiles("update-interactive-test", {
       "package.json": JSON.stringify({
@@ -207,6 +220,86 @@ describe("bun update --interactive formatting", () => {
     expect(stderr).not.toContain("overflow");
   });
 
+  it("should show workspace column with --filter", async () => {
+    const dir = tempDirWithFiles("update-interactive-workspace-col-test", {
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+      }),
+      "packages/pkg1/package.json": JSON.stringify({
+        name: "pkg1",
+        dependencies: {
+          "dep1": "1.0.0",
+        },
+      }),
+      "packages/pkg2/package.json": JSON.stringify({
+        name: "pkg2",
+        dependencies: {
+          "dep2": "1.0.0",
+        },
+      }),
+    });
+
+    // Test with --filter should include workspace column
+    const result = await Bun.spawn({
+      cmd: [bunExe(), "update", "--interactive", "--filter=*", "--dry-run"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "inherit",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const stderr = await new Response(result.stderr).text();
+
+    // Should not crash with workspace column
+    expect(stderr).not.toContain("panic");
+    expect(stderr).not.toContain("segfault");
+  });
+
+  it("should handle catalog dependencies in interactive update", async () => {
+    const dir = tempDirWithFiles("update-interactive-catalog-test", {
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        catalog: {
+          "shared-dep": "1.0.0",
+        },
+        workspaces: ["packages/*"],
+      }),
+      "packages/pkg1/package.json": JSON.stringify({
+        name: "pkg1",
+        dependencies: {
+          "shared-dep": "catalog:",
+        },
+      }),
+      "packages/pkg2/package.json": JSON.stringify({
+        name: "pkg2",
+        dependencies: {
+          "shared-dep": "catalog:",
+        },
+      }),
+    });
+
+    // Test interactive update with catalog dependencies
+    const result = await Bun.spawn({
+      cmd: [bunExe(), "update", "--interactive", "--filter=*", "--dry-run"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "inherit",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const stderr = await new Response(result.stderr).text();
+
+    // Should not crash with catalog dependencies
+    expect(stderr).not.toContain("panic");
+    expect(stderr).not.toContain("segfault");
+    expect(stderr).not.toContain("catalog: failed to resolve");
+  });
+
   it("should handle mixed dependency types with various name lengths", async () => {
     const dir = tempDirWithFiles("update-interactive-mixed-test", {
       "package.json": JSON.stringify({
@@ -264,4 +357,1596 @@ describe("bun update --interactive formatting", () => {
     expect(stderr).not.toContain("underflow");
     expect(stderr).not.toContain("overflow");
   });
+
+  it("should update packages when 'a' (select all) is used", async () => {
+    const dir = tempDirWithFiles("update-interactive-select-all", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "test-project",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0", // Old version
+        },
+      }),
+    });
+
+    // First install to get lockfile
+    const install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Test interactive update with 'a' to select all
+    const update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then Enter to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const stdout = await new Response(update.stdout).text();
+    const stderr = await new Response(update.stderr).text();
+    const output = stdout + stderr;
+
+    if (exitCode !== 0) {
+      console.error("Update failed with exit code:", exitCode);
+      console.error("Stdout:", stdout);
+      console.error("Stderr:", stderr);
+    }
+
+    // Should complete successfully
+    expect(exitCode).toBe(0);
+    expect(stderr).not.toContain("panic");
+
+    // Check if package.json was updated
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    // no-deps should be updated from 1.0.0 to 2.0.0
+    expect(packageJson.dependencies["no-deps"]).toBe("2.0.0");
+
+    // Check that the output shows the package was installed/updated
+    expect(output).toContain("Installing updates...");
+
+    // todo: Should show the installed package in the summary
+    // expect(output).toContain("installed no-deps@");
+
+    // Should save the lockfile
+    expect(output).toContain("Saved lockfile");
+  });
+
+  it("should handle workspace updates with recursive flag", async () => {
+    const dir = tempDirWithFiles("update-interactive-workspace-recursive", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        private: true,
+        workspaces: ["packages/*"],
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0", // Old version in workspace
+        },
+      }),
+    });
+
+    // First install
+    const install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Test interactive update with recursive flag
+    const update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Select all packages
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const stderr = await new Response(update.stderr).text();
+
+    expect(exitCode).toBe(0);
+    expect(stderr).not.toContain("panic");
+
+    // Check if workspace package was updated
+    const appPackageJson = await Bun.file(join(dir, "packages/app/package.json")).json();
+    expect(appPackageJson.dependencies["no-deps"]).toBe("2.0.0");
+  });
+
+  it("should handle catalog updates correctly", async () => {
+    const dir = tempDirWithFiles("update-interactive-catalog-actual", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+        catalog: {
+          "no-deps": "1.0.0", // Old version in catalog
+        },
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "catalog:",
+        },
+      }),
+    });
+
+    // First install
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const stdout = await new Response(update.stdout).text();
+    const stderr = await new Response(update.stderr).text();
+
+    expect(exitCode).toBe(0);
+    expect(stdout + stderr).not.toContain("panic");
+    expect(stdout + stderr).not.toContain("catalog: failed to resolve");
+
+    // Check if catalog was updated in root package.json
+    const rootPackageJson = await Bun.file(join(dir, "package.json")).json();
+    expect(rootPackageJson.catalog["no-deps"]).toBe("2.0.0");
+
+    // App package.json should still have catalog reference
+    const appPackageJson = await Bun.file(join(dir, "packages/app/package.json")).json();
+    expect(appPackageJson.dependencies["no-deps"]).toBe("catalog:");
+  });
+
+  it("should work correctly when run from inside a workspace directory", async () => {
+    const dir = tempDirWithFiles("update-interactive-from-workspace", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+      }),
+      "packages/app1/package.json": JSON.stringify({
+        name: "@test/app1",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0",
+        },
+      }),
+      "packages/app2/package.json": JSON.stringify({
+        name: "@test/app2",
+        version: "1.0.0",
+        dependencies: {
+          "dep-with-tags": "1.0.0",
+        },
+      }),
+    });
+
+    // First install from root
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update from inside workspace
+    const workspaceDir = join(dir, "packages/app1");
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: workspaceDir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+    const stderr = await new Response(update.stderr).text();
+    const combined = output + stderr;
+
+    // Should not fail with FileNotFound
+    expect(exitCode).toBe(0);
+    expect(combined).not.toContain("FileNotFound");
+    expect(combined).not.toContain("Failed to update");
+
+    // Check that both workspace packages were updated
+    const app1Json = await Bun.file(join(dir, "packages/app1/package.json")).json();
+    const app2Json = await Bun.file(join(dir, "packages/app2/package.json")).json();
+
+    expect(app1Json.dependencies["no-deps"]).toBe("2.0.0");
+    expect(app2Json.dependencies["dep-with-tags"]).toBe("3.0.0");
+  });
+
+  it("should handle basic interactive update with select all", async () => {
+    const dir = tempDirWithFiles("update-interactive-basic", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "test-project",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    expect(exitCode).toBe(0);
+
+    // Check if package was updated
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    expect(packageJson.dependencies["no-deps"]).toBe("2.0.0");
+  });
+
+  it("should preserve version prefixes for all semver range types in catalogs", async () => {
+    const dir = tempDirWithFiles("update-interactive-semver-prefixes", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+        catalog: {
+          "no-deps": "^1.0.0",
+          "dep-with-tags": "~1.0.0",
+          "a-dep": ">=1.0.5",
+        },
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        dependencies: {
+          "no-deps": "catalog:",
+          "dep-with-tags": "catalog:",
+          "a-dep": "catalog:",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    expect(exitCode).toBe(0);
+
+    // Check if prefixes were preserved
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+
+    // All prefixes should be preserved (versions may or may not change)
+    expect(packageJson.catalog["no-deps"]).toMatch(/^\^/);
+    expect(packageJson.catalog["dep-with-tags"]).toMatch(/^~/);
+    expect(packageJson.catalog["a-dep"]).toMatch(/^>=/);
+  });
+
+  it("should handle catalog updates in workspaces.catalogs object", async () => {
+    const dir = tempDirWithFiles("update-interactive-workspaces-catalogs", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: {
+          packages: ["packages/*"],
+          catalogs: {
+            "tools": {
+              "no-deps": "^1.0.0",
+              "dep-with-tags": "~1.0.0",
+            },
+            "frameworks": {
+              "a-dep": "^1.0.5",
+              "normal-dep-and-dev-dep": "^1.0.0",
+            },
+          },
+        },
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        dependencies: {
+          "no-deps": "catalog:tools",
+          "a-dep": "catalog:frameworks",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+    expect(output).toContain("Installing updates...");
+
+    // Check if catalogs were updated correctly
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+
+    // Prefixes should be preserved
+    expect(packageJson.workspaces.catalogs.tools["no-deps"]).toMatch(/^\^/);
+    expect(packageJson.workspaces.catalogs.tools["dep-with-tags"]).toMatch(/^~/);
+  });
+
+  it("should handle mixed workspace and catalog dependencies", async () => {
+    const dir = tempDirWithFiles("update-interactive-mixed-deps", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+        catalog: {
+          "no-deps": "^1.0.0",
+        },
+      }),
+      "packages/lib/package.json": JSON.stringify({
+        name: "@test/lib",
+        version: "1.0.0",
+        dependencies: {
+          "a-dep": "^1.0.5",
+        },
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        dependencies: {
+          "@test/lib": "workspace:*",
+          "no-deps": "catalog:",
+          "dep-with-tags": "~1.0.0",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    expect(exitCode).toBe(0);
+
+    // Check updates were applied correctly
+    const appJson = await Bun.file(join(dir, "packages/app/package.json")).json();
+    const libJson = await Bun.file(join(dir, "packages/lib/package.json")).json();
+
+    // Workspace dependency should remain unchanged
+    expect(appJson.dependencies["@test/lib"]).toBe("workspace:*");
+
+    // Regular dependencies should be updated with prefix preserved
+    expect(appJson.dependencies["dep-with-tags"]).toMatch(/^~/);
+    expect(libJson.dependencies["a-dep"]).toMatch(/^\^/);
+  });
+
+  it("should handle selecting specific packages in interactive mode", async () => {
+    const dir = tempDirWithFiles("update-interactive-selective", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "test-project",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0",
+          "dep-with-tags": "1.0.0",
+          "a-dep": "1.0.5",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update that selects only first package (space toggles, arrow down, enter)
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send keyboard navigation: space to toggle, arrow down, enter to confirm
+    update.stdin.write(" \u001b[B\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+    expect(output).toContain("Selected 1 package to update");
+
+    // Check only one package was updated
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+
+    // Since we toggled only the first package, check that only one was updated
+    // The actual package updated depends on the order, so we check that exactly one changed
+    let updatedCount = 0;
+    if (packageJson.dependencies["no-deps"] !== "1.0.0") updatedCount++;
+    if (packageJson.dependencies["dep-with-tags"] !== "1.0.0") updatedCount++;
+    if (packageJson.dependencies["a-dep"] !== "1.0.5") updatedCount++;
+    expect(updatedCount).toBe(1);
+  });
+
+  it("should handle empty catalog definitions gracefully", async () => {
+    const dir = tempDirWithFiles("update-interactive-empty-catalog", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+        catalog: {},
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        dependencies: {
+          "no-deps": "^1.0.0",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    expect(exitCode).toBe(0);
+
+    // Check workspace package was updated normally
+    const appJson = await Bun.file(join(dir, "packages/app/package.json")).json();
+    expect(appJson.dependencies["no-deps"]).toBe("^2.0.0");
+
+    // Root catalog should remain empty
+    const rootJson = await Bun.file(join(dir, "package.json")).json();
+    expect(Object.keys(rootJson.catalog)).toHaveLength(0);
+  });
+
+  it("should handle cancellation (Ctrl+C) gracefully", async () => {
+    const dir = tempDirWithFiles("update-interactive-cancel", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "test-project",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update and send Ctrl+C
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send Ctrl+C to cancel
+    update.stdin.write("\u0003");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+    expect(output).toContain("Cancelled");
+
+    // Check package.json was not modified
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    expect(packageJson.dependencies["no-deps"]).toBe("1.0.0");
+  });
+
+  it("should handle packages with pre-release versions correctly", async () => {
+    const dir = tempDirWithFiles("update-interactive-prerelease", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "test-project",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0",
+          "dep-with-tags": "^1.0.0",
+          "a-dep": "~1.0.5",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    expect(exitCode).toBe(0);
+
+    // Check version prefixes are preserved
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+
+    // Prefixes should be preserved
+    expect(packageJson.dependencies["dep-with-tags"]).toMatch(/^\^/);
+    expect(packageJson.dependencies["a-dep"]).toMatch(/^~/);
+  });
+
+  it("should update catalog in workspaces object (not workspaces.catalogs)", async () => {
+    const dir = tempDirWithFiles("update-interactive-workspaces-catalog", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: {
+          packages: ["packages/*"],
+          catalog: {
+            "no-deps": "^1.0.0",
+            "dep-with-tags": "~1.0.0",
+          },
+        },
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        dependencies: {
+          "no-deps": "catalog:",
+          "dep-with-tags": "catalog:",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+    expect(output).toContain("Installing updates...");
+
+    // Check catalog was updated with preserved prefixes
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    expect(packageJson.workspaces.catalog["no-deps"]).toBe("^2.0.0");
+    expect(packageJson.workspaces.catalog["dep-with-tags"]).toMatch(/^~/);
+  });
+
+  it("should handle scoped packages in catalogs correctly", async () => {
+    const dir = tempDirWithFiles("update-interactive-scoped-catalog", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+        catalog: {
+          "@scoped/has-bin-entry": "^1.0.0",
+          "no-deps": "~1.0.0",
+          "dep-with-tags": ">=1.0.0",
+        },
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        dependencies: {
+          "@scoped/has-bin-entry": "catalog:",
+          "no-deps": "catalog:",
+          "dep-with-tags": "catalog:",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    expect(exitCode).toBe(0);
+
+    // Check scoped packages were updated with preserved prefixes
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    expect(packageJson.catalog["@scoped/has-bin-entry"]).toMatch(/^\^/);
+    expect(packageJson.catalog["no-deps"]).toMatch(/^~/);
+    expect(packageJson.catalog["dep-with-tags"]).toMatch(/^>=/);
+  });
+
+  it("should handle catalog updates when running from root with filter", async () => {
+    const dir = tempDirWithFiles("update-interactive-filter-catalog", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+        catalog: {
+          "no-deps": "^1.0.0",
+          "dep-with-tags": "~1.0.0",
+        },
+      }),
+      "packages/app1/package.json": JSON.stringify({
+        name: "@test/app1",
+        dependencies: {
+          "no-deps": "catalog:",
+        },
+      }),
+      "packages/app2/package.json": JSON.stringify({
+        name: "@test/app2",
+        dependencies: {
+          "dep-with-tags": "catalog:",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with filter
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--filter=@test/app2", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+
+    // Check catalog was updated
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    expect(packageJson.catalog["dep-with-tags"]).toMatch(/^~/);
+    //todo: actually check the catalog was updated
+  });
+
+  it("should handle multiple catalog definitions with same package", async () => {
+    const dir = tempDirWithFiles("update-interactive-multi-catalog", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: {
+          packages: ["packages/*"],
+          catalogs: {
+            "dev": {
+              "no-deps": "^1.0.0",
+            },
+            "prod": {
+              "no-deps": "~1.0.0",
+            },
+          },
+        },
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        dependencies: {
+          "no-deps": "catalog:prod",
+        },
+        devDependencies: {
+          "no-deps": "catalog:dev",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+
+    // Check both catalogs were updated with preserved prefixes
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    expect(packageJson.workspaces.catalogs.dev["no-deps"]).toBe("^2.0.0");
+    expect(packageJson.workspaces.catalogs.prod["no-deps"]).toMatch(/^~/);
+    //todo: actually check the catalog was updated
+  });
+
+  it("should handle version ranges with multiple conditions", async () => {
+    const dir = tempDirWithFiles("update-interactive-complex-ranges", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+        catalog: {
+          "no-deps": "^1.0.0 || ^2.0.0",
+          "dep-with-tags": ">=1.0.0 <3.0.0",
+        },
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        dependencies: {
+          "no-deps": "catalog:",
+          "dep-with-tags": "catalog:",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with piped input
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    expect(exitCode).toBe(0);
+
+    // Check complex ranges are handled (they might be simplified)
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    // Complex ranges might be simplified to latest version
+    expect(packageJson.catalog["no-deps"]).toBeDefined();
+    expect(packageJson.catalog["dep-with-tags"]).toBeDefined();
+  });
+
+  it("should handle dry-run mode correctly", async () => {
+    const dir = tempDirWithFiles("update-interactive-dry-run", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "test-project",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0",
+          "dep-with-tags": "1.0.0",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with dry-run
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--latest", "--dry-run"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+    expect(output).toContain("Selected");
+
+    // Check packages were NOT updated (dry-run)
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    expect(packageJson.dependencies["no-deps"]).toBe("1.0.0");
+    expect(packageJson.dependencies["dep-with-tags"]).toBe("1.0.0");
+  });
+
+  it("should handle keyboard navigation correctly", async () => {
+    const dir = tempDirWithFiles("update-interactive-navigation", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "test-project",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0",
+          "dep-with-tags": "1.0.0",
+          "a-dep": "1.0.5",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update with keyboard navigation:
+    // - n (select none)
+    // - i (invert selection)
+    // - Enter (confirm)
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send keyboard navigation commands
+    update.stdin.write("ni\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+    expect(output).toContain("Selected 3 packages to update");
+  });
+
+  // Comprehensive tests from separate file
+  it("comprehensive interactive update test with all scenarios", async () => {
+    const dir = tempDirWithFiles("update-interactive-comprehensive", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      // Root package.json with catalog definitions and dependencies
+      "package.json": JSON.stringify({
+        name: "root-project",
+        version: "1.0.0",
+        private: true,
+        workspaces: ["packages/*"],
+        // Catalog with old versions that can be updated
+        catalog: {
+          "no-deps": "^1.0.0",
+          "dep-with-tags": "~1.0.0",
+        },
+        // Some root dependencies
+        dependencies: {
+          "a-dep": "^1.0.5",
+        },
+        devDependencies: {
+          "normal-dep-and-dev-dep": "^1.0.0",
+        },
+      }),
+      // Workspace 1: Uses catalog references and has its own dependencies
+      "packages/app1/package.json": JSON.stringify({
+        name: "@test/app1",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "catalog:", // References catalog
+          "dep-with-tags": "catalog:", // References catalog
+          "a-dep": "^1.0.5", // Regular dependency (same as root)
+        },
+        devDependencies: {
+          "normal-dep-and-dev-dep": "^1.0.0", // Dev dependency
+        },
+      }),
+      // Workspace 2: Different dependencies to test workspace-specific updates
+      "packages/app2/package.json": JSON.stringify({
+        name: "@test/app2",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "catalog:", // References catalog
+          "a-dep": "^1.0.5", // Regular dependency
+        },
+        devDependencies: {
+          "dep-with-tags": "^1.0.0", // Different from catalog - should update independently
+        },
+      }),
+    });
+
+    // First install to establish the lockfile
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const installExitCode = await install.exited;
+    if (installExitCode !== 0) {
+      const stderr = await new Response(install.stderr).text();
+      console.error("Install failed:", stderr);
+    }
+    expect(installExitCode).toBe(0);
+
+    // Run interactive update and select all packages
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send 'a' to select all, then newline to confirm
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const updateExitCode = await update.exited;
+    const stdout = await new Response(update.stdout).text();
+    const stderr = await new Response(update.stderr).text();
+    const combined = stdout + stderr;
+
+    // Should complete successfully
+    expect(updateExitCode).toBe(0);
+    expect(combined).not.toContain("panic");
+    expect(combined).not.toContain("FileNotFound");
+    expect(combined).not.toContain("Failed to update");
+
+    // Verify catalog definitions were updated in root package.json
+    const rootPackageJson = await Bun.file(join(dir, "package.json")).json();
+
+    // Catalog should be updated while preserving prefixes
+    expect(rootPackageJson.catalog["no-deps"]).toBe("^2.0.0");
+    expect(rootPackageJson.catalog["dep-with-tags"]).toMatch(/^~/);
+
+    // Root dependencies should be updated
+    expect(rootPackageJson.dependencies["a-dep"]).toMatch(/^\^/);
+    expect(rootPackageJson.devDependencies["normal-dep-and-dev-dep"]).toMatch(/^\^/);
+
+    // App1 should have catalog references preserved but regular deps updated
+    const app1Json = await Bun.file(join(dir, "packages/app1/package.json")).json();
+    expect(app1Json.dependencies["no-deps"]).toBe("catalog:"); // Catalog ref preserved
+    expect(app1Json.dependencies["dep-with-tags"]).toBe("catalog:"); // Catalog ref preserved
+    expect(app1Json.dependencies["a-dep"]).toMatch(/^\^/); // Regular dep updated
+    expect(app1Json.devDependencies["normal-dep-and-dev-dep"]).toMatch(/^\^/); // Dev dep updated
+
+    // App2 should have catalog references preserved and independent deps updated
+    const app2Json = await Bun.file(join(dir, "packages/app2/package.json")).json();
+    expect(app2Json.dependencies["no-deps"]).toBe("catalog:"); // Catalog ref preserved
+    expect(app2Json.dependencies["a-dep"]).toMatch(/^\^/); // Regular dep updated
+    expect(app2Json.devDependencies["dep-with-tags"]).toMatch(/^\^/); // Independent dep updated
+
+    // Verify lockfile exists and is valid
+    console.log("Checking lockfile...");
+    const lockfilePath = join(dir, "bun.lock");
+    const lockfileExists = await Bun.file(lockfilePath).exists();
+    expect(lockfileExists).toBe(true);
+
+    // Run bun install again to verify no changes are needed
+    await using verifyInstall = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const verifyExitCode = await verifyInstall.exited;
+    const verifyStdout = await new Response(verifyInstall.stdout).text();
+    const verifyStderr = await new Response(verifyInstall.stderr).text();
+    const verifyCombined = verifyStdout + verifyStderr;
+
+    expect(verifyExitCode).toBe(0);
+
+    // Should indicate no changes are needed - just check that no new packages are being installed
+    expect(verifyCombined).not.toContain("Installing");
+    // "Saved lockfile" is fine even when no changes, so don't check for it
+  });
+
+  it("interactive update with workspace filters", async () => {
+    const dir = tempDirWithFiles("update-interactive-filter", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        private: true,
+        workspaces: ["packages/*"],
+        catalog: {
+          "no-deps": "^1.0.0",
+        },
+      }),
+      "packages/frontend/package.json": JSON.stringify({
+        name: "@test/frontend",
+        dependencies: {
+          "no-deps": "catalog:",
+          "a-dep": "^1.0.5",
+        },
+      }),
+      "packages/backend/package.json": JSON.stringify({
+        name: "@test/backend",
+        dependencies: {
+          "dep-with-tags": "^1.0.0",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Update only frontend workspace
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--filter=@test/frontend", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    expect(exitCode).toBe(0);
+
+    // Verify catalog was updated (even with filter)
+    const rootJson = await Bun.file(join(dir, "package.json")).json();
+    expect(rootJson.catalog["no-deps"]).toBe("^2.0.0");
+
+    // Verify frontend was updated
+    const frontendJson = await Bun.file(join(dir, "packages/frontend/package.json")).json();
+    expect(frontendJson.dependencies["a-dep"]).toMatch(/^\^/);
+
+    // Verify backend was not updated (should still be old version)
+    const backendJson = await Bun.file(join(dir, "packages/backend/package.json")).json();
+    expect(backendJson.dependencies["dep-with-tags"]).toBe("^1.0.0");
+  });
+
+  it("interactive update with workspaces.catalogs structure", async () => {
+    const dir = tempDirWithFiles("update-interactive-workspaces-catalogs", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "root",
+        version: "1.0.0",
+        workspaces: {
+          packages: ["packages/*"],
+          catalogs: {
+            "shared": {
+              "no-deps": "^1.0.0",
+              "dep-with-tags": "~1.0.0",
+            },
+            "tools": {
+              "a-dep": ">=1.0.5",
+            },
+          },
+        },
+      }),
+      "packages/app/package.json": JSON.stringify({
+        name: "@test/app",
+        dependencies: {
+          "no-deps": "catalog:shared",
+          "dep-with-tags": "catalog:shared",
+          "a-dep": "catalog:tools",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+    expect(output).toContain("Installing updates..."); // Should show install message
+
+    // Verify workspaces.catalogs were updated with preserved prefixes AND new versions
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+
+    // Check that versions actually changed from original static values
+    expect(packageJson.workspaces.catalogs.shared["no-deps"]).not.toBe("^1.0.0"); // Should be newer
+    expect(packageJson.workspaces.catalogs.shared["dep-with-tags"]).not.toBe("~1.0.0"); // Should be newer
+
+    // For a-dep, check if it changed or at least verify it has the right prefix
+    // (Some versions might not change if already satisfied)
+    const aDep = packageJson.workspaces.catalogs.tools["a-dep"];
+    if (aDep !== ">=1.0.5") {
+      // Version changed - verify it starts with >=
+      expect(aDep).toMatch(/^>=/);
+    } else {
+      // Version didn't change - that's ok if the constraint was already satisfied
+      expect(aDep).toBe(">=1.0.5");
+    }
+
+    // Check that prefixes are preserved
+    expect(packageJson.workspaces.catalogs.shared["no-deps"]).toMatch(/^\^/);
+    expect(packageJson.workspaces.catalogs.shared["dep-with-tags"]).toMatch(/^~/);
+    expect(packageJson.workspaces.catalogs.tools["a-dep"]).toMatch(/^>=/);
+
+    // App package should still have catalog references (unchanged)
+    const appJson = await Bun.file(join(dir, "packages/app/package.json")).json();
+    expect(appJson.dependencies["no-deps"]).toBe("catalog:shared");
+    expect(appJson.dependencies["dep-with-tags"]).toBe("catalog:shared");
+    expect(appJson.dependencies["a-dep"]).toBe("catalog:tools");
+  });
+
+  it("interactive update dry run mode", async () => {
+    const dir = tempDirWithFiles("update-interactive-dry-run", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "test-project",
+        version: "1.0.0",
+        dependencies: {
+          "no-deps": "1.0.0",
+          "dep-with-tags": "1.0.0",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Store original package.json content
+    const originalContent = await Bun.file(join(dir, "package.json")).text();
+
+    // Run interactive update with dry-run
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "--latest", "--dry-run"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    const output = await new Response(update.stdout).text();
+
+    expect(exitCode).toBe(0);
+    expect(output).toContain("Dry run");
+
+    // Verify package.json was NOT modified
+    const afterContent = await Bun.file(join(dir, "package.json")).text();
+    expect(afterContent).toBe(originalContent);
+
+    // Parse and verify versions are still old
+    const packageJson = await Bun.file(join(dir, "package.json")).json();
+    expect(packageJson.dependencies["no-deps"]).toBe("1.0.0");
+    expect(packageJson.dependencies["dep-with-tags"]).toBe("1.0.0");
+  });
+
+  it("interactive update with mixed dependency types", async () => {
+    const dir = tempDirWithFiles("update-interactive-mixed", {
+      "bunfig.toml": `[install]
+cache = false
+registry = "${registryUrl}"
+`,
+      "package.json": JSON.stringify({
+        name: "test-project",
+        version: "1.0.0",
+        workspaces: ["packages/*"],
+        catalog: {
+          "a-dep": "^1.0.5",
+        },
+        dependencies: {
+          "no-deps": "^1.0.0",
+        },
+        devDependencies: {
+          "dep-with-tags": "~1.0.0",
+        },
+        peerDependencies: {
+          "a-dep": ">=1.0.5",
+        },
+        optionalDependencies: {
+          "normal-dep-and-dev-dep": "^1.0.0",
+        },
+      }),
+      "packages/workspace1/package.json": JSON.stringify({
+        name: "@test/workspace1",
+        dependencies: {
+          "a-dep": "catalog:",
+          "@test/workspace2": "workspace:*", // Workspace dependency
+        },
+        devDependencies: {
+          "no-deps": "^1.0.0",
+        },
+      }),
+      "packages/workspace2/package.json": JSON.stringify({
+        name: "@test/workspace2",
+        version: "1.0.0",
+        dependencies: {
+          "a-dep": "catalog:",
+        },
+      }),
+    });
+
+    // Install first
+    await using install = Bun.spawn({
+      cmd: [bunExe(), "install"],
+      cwd: dir,
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    expect(await install.exited).toBe(0);
+
+    // Run interactive update
+    await using update = Bun.spawn({
+      cmd: [bunExe(), "update", "-i", "-r", "--latest"],
+      cwd: dir,
+      env: bunEnv,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    update.stdin.write("a\n");
+    update.stdin.end();
+
+    const exitCode = await update.exited;
+    expect(exitCode).toBe(0);
+
+    // Verify all dependency types were handled correctly
+    const rootJson = await Bun.file(join(dir, "package.json")).json();
+    expect(rootJson.catalog["a-dep"]).toMatch(/^\^/); // Catalog updated
+    expect(rootJson.dependencies["no-deps"]).toMatch(/^\^/); // Regular dep updated
+    expect(rootJson.devDependencies["dep-with-tags"]).toMatch(/^~/); // Dev dep updated with prefix preserved
+    expect(rootJson.peerDependencies["a-dep"]).toMatch(/^>=/); // Peer dep updated with prefix preserved
+    expect(rootJson.optionalDependencies["normal-dep-and-dev-dep"]).toMatch(/^\^/); // Optional dep updated
+
+    // Verify workspace dependencies
+    const ws1Json = await Bun.file(join(dir, "packages/workspace1/package.json")).json();
+    expect(ws1Json.dependencies["a-dep"]).toBe("catalog:"); // Catalog ref preserved
+    expect(ws1Json.dependencies["@test/workspace2"]).toBe("workspace:*"); // Workspace ref preserved
+    expect(ws1Json.devDependencies["no-deps"]).toMatch(/^\^/); // Regular dep updated
+
+    const ws2Json = await Bun.file(join(dir, "packages/workspace2/package.json")).json();
+    expect(ws2Json.dependencies["a-dep"]).toBe("catalog:"); // Catalog ref preserved
+  });
 });
diff --git a/test/internal/ban-limits.json b/test/internal/ban-limits.json
index bb887034c6..9671650d8f 100644
--- a/test/internal/ban-limits.json
+++ b/test/internal/ban-limits.json
@@ -30,7 +30,7 @@
   "std.enums.tagName(": 2,
   "std.fs.Dir": 170,
   "std.fs.File": 62,
-  "std.fs.cwd": 103,
+  "std.fs.cwd": 104,
   "std.log": 1,
   "std.mem.indexOfAny(u8": 0,
   "std.unicode": 30,
diff --git a/test/no-validate-exceptions.txt b/test/no-validate-exceptions.txt
index de17bff358..8bdb9db4ee 100644
--- a/test/no-validate-exceptions.txt
+++ b/test/no-validate-exceptions.txt
@@ -200,6 +200,7 @@ test/cli/install/isolated-install.test.ts
 test/cli/install/bun-publish.test.ts
 test/cli/install/bun-lock.test.ts
 test/cli/install/bun-install-lifecycle-scripts.test.ts
+test/cli/update_interactive_formatting.test.ts
 # ProgramExecutable::initializeGlobalProperties
 # missing RELEASE_AND_RETURN
 test/js/node/test/parallel/test-repl-syntax-error-handling.js