refactor(stdlib): remove lru-cache native binding

Cargo.toml

@@ -16,7 +16,6 @@ members = [
     "crates/perry-ext-bcrypt",
     "crates/perry-ext-argon2",
     "crates/perry-perex",
-    "crates/perry-ext-lru-cache",
     "crates/perry-ext-better-sqlite3",
     "crates/perry-ext-zlib",
     "crates/perry-ext-exponential-backoff",
@@ -477,7 +476,6 @@ perry-ext-nanoid = { path = "crates/perry-ext-nanoid" }
 perry-ext-bcrypt = { path = "crates/perry-ext-bcrypt" }
 perry-ext-argon2 = { path = "crates/perry-ext-argon2" }
 perry-perex = { path = "crates/perry-perex" }
-perry-ext-lru-cache = { path = "crates/perry-ext-lru-cache" }
 perry-ext-better-sqlite3 = { path = "crates/perry-ext-better-sqlite3" }
 perry-ext-zlib = { path = "crates/perry-ext-zlib" }
 perry-ext-exponential-backoff = { path = "crates/perry-ext-exponential-backoff" }

changelog.d/10708-remove-lrucache-binding.md

@@ -0,0 +1,9 @@
+**Removed the native `lru-cache` binding** — `import { LRUCache } from "lru-cache"` now resolves to
+the real npm package, compiled from source. Native `instanceof` threw `Right-hand side of
+'instanceof' is not callable` and `constructor.name` was undefined (the handle isn't a real class
+object); `cache.forEach(...)` silently visited nothing and a `dispose` callback was never invoked,
+where npm's real implementation does both. Also removes the dedicated #10293 native-subclass
+machinery (`class X extends LRUCache` support for a binding with no runtime class value) — the real
+compiled package's `LRUCache` is an ordinary JS class, so subclassing needs no special support at
+all. Fixes #10685. Requires #10439's import-provenance fix (#10699) to reach the real package at its
+default import name.

crates/perry-api-manifest/src/entries.rs

@@ -92,7 +92,6 @@ pub const NATIVE_MODULES: &[&str] = &[
     "dns/promises",       // (duplicate — kept for parity)
     "url",                // URL / URLSearchParams
     // ── More third-party npm packages ──
-    "lru-cache",           // LRU cache
     "commander",           // CLI argument parser
     "decimal.js",          // arbitrary-precision decimals
     "bignumber.js",        // arbitrary-precision big numbers

crates/perry-api-manifest/src/entries/part_1.rs

@@ -1000,22 +1000,6 @@ pub(crate) const API_MANIFEST_PART_1: &[ApiEntry] = &[
     method("domain", "remove", true, None),
     method("domain", "enter", true, None),
     method("domain", "exit", true, None),
-    method_sig(
-        "lru-cache",
-        "default",
-        false,
-        None,
-        &[p_any("p0")],
-        TypeSpec::Any,
-    ),
-    method("lru-cache", "get", true, None),
-    method("lru-cache", "set", true, None),
-    method("lru-cache", "has", true, None),
-    method("lru-cache", "delete", true, None),
-    method("lru-cache", "clear", true, None),
-    method("lru-cache", "size", true, None),
-    // `peek(key)` — read without refreshing recency (#7136).
-    method("lru-cache", "peek", true, None),
     method("commander", "name", true, None),
     method("commander", "description", true, None),
     method("commander", "version", true, None),

crates/perry-codegen/src/expr/mod.rs

@@ -148,7 +148,7 @@ pub(crate) use write_barrier::{
     emit_write_barrier_slot_generation_tested, emit_write_barrier_slot_on_block,
     emit_write_barrier_slot_value_and_generation_tested, lower_array_super_init,
     lower_event_emitter_async_resource_subclass_init, lower_event_emitter_subclass_init,
-    lower_lru_cache_subclass_init, lower_node_stream_super_init, lower_stream_super_init,
+    lower_node_stream_super_init, lower_stream_super_init,
 };
 
 // Issue #1098 phase 3: the `FnCtx` definition stays in this trunk, but its

crates/perry-codegen/src/expr/this_super_call.rs

@@ -14,8 +14,8 @@ use crate::types::{DOUBLE, I1, I32, I64, PTR};
 
 use super::{
     lower_array_super_init, lower_event_emitter_async_resource_subclass_init,
-    lower_event_emitter_subclass_init, lower_expr, lower_lru_cache_subclass_init,
-    lower_node_stream_super_init, lower_stream_super_init, nanbox_pointer_inline, FnCtx,
+    lower_event_emitter_subclass_init, lower_expr, lower_node_stream_super_init,
+    lower_stream_super_init, nanbox_pointer_inline, FnCtx,
 };
 
 /// Enter one derived constructor's `super()` binding scope.
@@ -936,35 +936,6 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                         )?;
                         return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
                     }
-                    // #10293: `class X extends LRUCache` (lru-cache).
-                    // `LRUCache` is lowered as a compile-time pattern on the
-                    // identifier and has no runtime value, so `extends` would
-                    // otherwise throw "Class extends value is not a
-                    // constructor". Same treatment as the node:stream bases:
-                    // create the native cache and install its surface on
-                    // `this`. path-scurry (via glob) is the case that needs it.
-                    if parent_name.as_str() == "LRUCache" {
-                        let operands: Vec<_> = super_args.iter().collect();
-                        return rooting::with_operands_rooted(ctx, &operands, |ctx, lowered| {
-                            let options = lowered.first().cloned().unwrap_or_else(|| {
-                                double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED))
-                            });
-                            let this_box = match ctx.this_stack.last().cloned() {
-                                Some(slot) => ctx.block().load(DOUBLE, &slot),
-                                None => {
-                                    double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED))
-                                }
-                            };
-                            lower_lru_cache_subclass_init(ctx, &this_box, &options);
-                            bind_derived_this_after_super(ctx);
-                            crate::lower_call::apply_field_initializers_recursive(
-                                ctx,
-                                &current_class_name,
-                                crate::lower_call::FieldInitMode::SelfOnly,
-                            )?;
-                            Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)))
-                        });
-                    }
                     if parent_name.as_str() == "EventEmitterAsyncResource" {
                         let operands: Vec<_> = super_args.iter().collect();
                         return rooting::with_operands_rooted(ctx, &operands, |ctx, lowered| {

crates/perry-codegen/src/expr/write_barrier.rs

@@ -1279,22 +1279,6 @@ pub(crate) fn lower_event_emitter_subclass_init(ctx: &mut FnCtx<'_>, this_box: &
     );
 }
 
-/// #10293: `super(options)` for a source-compiled `class X extends LRUCache`.
-/// Installs the implemented cache surface directly onto `this` — `LRUCache` is
-/// a compile-time lowering with no runtime value, so there is no base
-/// constructor to call.
-pub(crate) fn lower_lru_cache_subclass_init(
-    ctx: &mut FnCtx<'_>,
-    this_box: &str,
-    options_box: &str,
-) {
-    ctx.block().call(
-        DOUBLE,
-        "js_lru_cache_subclass_init",
-        &[(DOUBLE, this_box), (DOUBLE, options_box)],
-    );
-}
-
 pub(crate) fn lower_event_emitter_async_resource_subclass_init(
     ctx: &mut FnCtx<'_>,
     this_box: &str,

crates/perry-codegen/src/lower_call/builtin.rs

@@ -633,23 +633,6 @@ pub(super) fn lower_builtin_new<'a>(
             let result = ctx.block().call(DOUBLE, runtime_fn, &[(DOUBLE, &opts_box)]);
             Ok(Some(result))
         }
-        // lru-cache LRUCache — `new LRUCache({ max, ttl, updateAgeOnGet })`.
-        // The runtime parses the whole NaN-boxed options object itself
-        // (`js_lru_cache_new(options: f64)`), so we just lower the options
-        // argument and hand it through — no static field extraction, which
-        // means dynamic/variable options objects work too. A missing options
-        // argument passes `undefined`, which the runtime rejects with the
-        // same `TypeError` npm's constructor destructuring raises.
-        "LRUCache" => {
-            // npm's constructor ignores everything past the options object,
-            // but the arguments are still evaluated — the tail is lowered
-            // for its side effects so `new LRUCache(opts, f())` still calls
-            // `f`. #6986: `opts_val` was held across that lowering.
-            let opts_val = adopt_leading_arg_discard_rest(ctx, args, group)?;
-            let blk = ctx.block();
-            let handle = blk.call(I64, "js_lru_cache_new", &[(DOUBLE, &opts_val)]);
-            Ok(Some(nanbox_pointer_inline(blk, &handle)))
-        }
         // (`WebSocketServer` is handled by an earlier branch lower in this
         // file — pre-existing from 2026-04-14. No new branch needed here.)
         // pg Client — `new Client(config)` matching npm pg's API: synchronous

crates/perry-codegen/src/lower_call/native_table/node_misc.rs

@@ -281,79 +281,6 @@ pub(super) const NODE_MISC_ROWS: &[NativeModSig] = &[
         args: &[NA_F64, NA_F64, NA_F64, NA_F64],
         ret: NR_F64,
     },
-    // ========== LRU Cache ==========
-    NativeModSig {
-        module: "lru-cache",
-        has_receiver: false,
-        method: "default",
-        class_filter: None,
-        runtime: "js_lru_cache_new",
-        args: &[NA_F64],
-        ret: NR_HANDLE_ID,
-    },
-    NativeModSig {
-        module: "lru-cache",
-        has_receiver: true,
-        method: "get",
-        class_filter: None,
-        runtime: "js_lru_cache_get",
-        args: &[NA_F64],
-        ret: NR_F64,
-    },
-    NativeModSig {
-        module: "lru-cache",
-        has_receiver: true,
-        method: "set",
-        class_filter: None,
-        runtime: "js_lru_cache_set",
-        args: &[NA_F64, NA_F64],
-        ret: NR_HANDLE_ID,
-    },
-    NativeModSig {
-        module: "lru-cache",
-        has_receiver: true,
-        method: "has",
-        class_filter: None,
-        runtime: "js_lru_cache_has",
-        args: &[NA_F64],
-        ret: NR_F64,
-    },
-    NativeModSig {
-        module: "lru-cache",
-        has_receiver: true,
-        method: "delete",
-        class_filter: None,
-        runtime: "js_lru_cache_delete",
-        args: &[NA_F64],
-        ret: NR_F64,
-    },
-    NativeModSig {
-        module: "lru-cache",
-        has_receiver: true,
-        method: "clear",
-        class_filter: None,
-        runtime: "js_lru_cache_clear",
-        args: &[],
-        ret: NR_VOID,
-    },
-    NativeModSig {
-        module: "lru-cache",
-        has_receiver: true,
-        method: "size",
-        class_filter: None,
-        runtime: "js_lru_cache_size",
-        args: &[],
-        ret: NR_F64,
-    },
-    NativeModSig {
-        module: "lru-cache",
-        has_receiver: true,
-        method: "peek",
-        class_filter: None,
-        runtime: "js_lru_cache_peek",
-        args: &[NA_F64],
-        ret: NR_F64,
-    },
     // ========== commander (CLI parsing) ==========
     // `new Command()` is dispatched separately by `lower_builtin_new` so it
     // produces a real CommanderHandle instead of an empty placeholder. The

crates/perry-codegen/src/lower_call/new_helpers.rs

@@ -86,7 +86,6 @@ pub(crate) enum NativeInstanceBase {
     Event,
     CustomEvent,
     DomException,
-    LruCache,
 }
 
 /// The native base a parent NAME denotes, if any.
@@ -112,14 +111,6 @@ pub(crate) fn native_instance_base(name: &str) -> Option<NativeInstanceBase> {
         "Event" => Some(NativeInstanceBase::Event),
         "CustomEvent" => Some(NativeInstanceBase::CustomEvent),
         "DOMException" => Some(NativeInstanceBase::DomException),
-        // #10293: `lru-cache`'s `LRUCache` is one of these too. It is a
-        // compile-time binding with no runtime class value, so `super(opts)`
-        // installs its surface onto `this` exactly like `EventEmitter` — and a
-        // subclass with NO constructor writes no `super()`, so without this arm
-        // `class C extends LRUCache {}` constructed bare and `c.set(...)` threw
-        // "set is not a function". The explicit-`super()` arm in
-        // `expr/this_super_call.rs` covers only the written-constructor case.
-        "LRUCache" => Some(NativeInstanceBase::LruCache),
         _ => None,
     }
 }
@@ -196,16 +187,6 @@ pub(crate) fn emit_native_instance_base_init(
             // (already lowered for their side effects) are not forwarded.
             crate::expr::lower_event_emitter_subclass_init(ctx, this_box);
         }
-        NativeInstanceBase::LruCache => {
-            // Unlike the emitter, the options bag IS load-bearing (`{ max }` is
-            // required by the binding), so forward the first argument — what a
-            // written `super(opts)` would have passed.
-            let options = lowered_args
-                .first()
-                .cloned()
-                .unwrap_or_else(|| undef.clone());
-            crate::expr::lower_lru_cache_subclass_init(ctx, this_box, &options);
-        }
         NativeInstanceBase::Array => {
             let n = lowered_args.len();
             let (args_ptr, args_len) = if n == 0 {

crates/perry-codegen/src/runtime_decls/stdlib_ffi.rs

@@ -42,8 +42,7 @@ pub fn declare_stdlib_ffi(module: &mut LlModule) {
     declare_third_party(module);
     // URL / URLSearchParams + WebSocket.
     declare_web(module);
-    // @perryts/pdf, commander, dotenv, date libs, decimal.js, ethers, lodash,
-    // lru-cache.
+    // @perryts/pdf, commander, dotenv, date libs, decimal.js, ethers, lodash.
     declare_utilities(module);
     // node:stream, EventEmitter, domain, StringDecoder, querystring, fastify,
     // nodemailer, rate-limit, validator.

crates/perry-codegen/src/runtime_decls/stdlib_ffi/utilities.rs

@@ -1,6 +1,6 @@
 //! Utility-package stdlib FFI declarations (extracted from stdlib_ffi.rs):
 //! @perryts/pdf, commander, dotenv, date libs (dayjs/datefns/moment),
-//! decimal.js, ethers, lodash, lru-cache.
+//! decimal.js, ethers, lodash.
 
 use crate::module::LlModule;
 use crate::types::{DOUBLE, I64, VOID};
@@ -221,15 +221,4 @@ pub(crate) fn declare_utilities(module: &mut LlModule) {
     module.declare_function("js_lodash_uniq", I64, &[I64]);
     module.declare_function("js_lodash_upper_case", I64, &[I64]);
     module.declare_function("js_lodash_upper_first", I64, &[I64]);
-
-    // ========== LRU Cache ==========
-    module.declare_function("js_lru_cache_clear", VOID, &[I64]);
-    module.declare_function("js_lru_cache_delete", DOUBLE, &[I64, DOUBLE]);
-    module.declare_function("js_lru_cache_get", DOUBLE, &[I64, DOUBLE]);
-    module.declare_function("js_lru_cache_has", DOUBLE, &[I64, DOUBLE]);
-    module.declare_function("js_lru_cache_new", I64, &[DOUBLE]);
-    module.declare_function("js_lru_cache_peek", DOUBLE, &[I64, DOUBLE]);
-    module.declare_function("js_lru_cache_set", I64, &[I64, DOUBLE, DOUBLE]);
-    module.declare_function("js_lru_cache_size", DOUBLE, &[I64]);
-    module.declare_function("js_lru_cache_subclass_init", DOUBLE, &[DOUBLE, DOUBLE]);
 }