fix(compile): survive binary/workspace skew; zstd, DOMException-subclass and panic-dedup gaps hit compiling a real npm CLI

changelog.d/7021-real-npm-cli-compile-gaps.md

@@ -0,0 +1,7 @@
+**Compile fixes from taking a real npm CLI (Socket Firewall) to a native binary** — five independent blockers, each fixed at its own layer:
+
+- **Auto-optimize feature skew**: cross-features the on-disk checkout's `perry-runtime`/`perry-stdlib` don't declare are now dropped (with a warning) instead of failing the whole cargo resolve and silently falling back to a link that's missing the routed ext entrypoints. The cargo-failure fallback message now explains the consequence and remedy.
+- **`perry-ext-zlib` zstd surface**: `zlib.createZstdCompress`/`createZstdDecompress`, the zstd one-shots, and the streaming write-codec are now implemented in the ext wrapper, so routing `node:zlib` no longer strips the only zstd implementation out of the link (undici's web-fetch content decoding references it unconditionally).
+- **`class X extends DOMException`**: new `js_dom_exception_subclass_init` wired through both the explicit `super()` lowering and the implicit-ctor chain walk — undici's module-init inheritability probe no longer aborts startup with `DOMException is not a function`.
+- **panic-runtime dedup**: prebuilt (panic=unwind) wrapper staticlibs co-linked with a panic=abort auto-optimized stdlib no longer die on `__rust_drop_panic` — the `panic_unwind` member is nominated for the nosharedeps fixed-point (kept only when the stdlib can't cover it), and panic symbols referenced by a sibling member are no longer localized. Allocator shims remain always-localized (a global wrapper malloc shim would break runtime pointer classification).
+- **`RegExp` call form via a rebound global**: `var R = globalThis.RegExp; R(src)` now constructs (with the spec's `RegExp(re)` identity shortcut) instead of returning `undefined` from the noop thunk — lodash's `runInContext` module init relied on exactly this.

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

@@ -214,6 +214,38 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                 )?;
                 return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
             }
+            // `class X extends DOMException` with a synthesized/pass-through
+            // constructor (`super(...args)`) must initialize the same surface
+            // as the fixed-arity super-call path above. Array reads past the
+            // spread argument count produce `undefined`, matching the optional
+            // message/name parameters.
+            let is_dom_exception = ctx
+                .classes
+                .get(&current_class_name)
+                .and_then(|c| c.extends_name.as_deref())
+                .map(|p| p == "DOMException")
+                .unwrap_or(false);
+            if is_dom_exception {
+                let zero_idx = "0".to_string();
+                let one_idx = "1".to_string();
+                let message =
+                    ctx.block()
+                        .call(DOUBLE, "js_array_get_f64", &[(I64, &arr), (I32, &zero_idx)]);
+                let name =
+                    ctx.block()
+                        .call(DOUBLE, "js_array_get_f64", &[(I64, &arr), (I32, &one_idx)]);
+                ctx.block().call(
+                    DOUBLE,
+                    "js_dom_exception_subclass_init",
+                    &[(DOUBLE, &this_box), (DOUBLE, &message), (DOUBLE, &name)],
+                );
+                crate::lower_call::apply_field_initializers_recursive(
+                    ctx,
+                    &current_class_name,
+                    crate::lower_call::FieldInitMode::SelfOnly,
+                )?;
+                return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
+            }
             if let Some(&child_cid) = ctx.class_ids.get(&current_class_name) {
                 let cid_str = child_cid.to_string();
                 let blk = ctx.block();
@@ -384,6 +416,7 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                             | "Response"
                             | "Event"
                             | "CustomEvent"
+                            | "DOMException"
                     ) || (is_stream_family_name
                         && !has_extends_expr)
                         || is_other_builtin_constructor_name(parent_name.as_str()))
@@ -709,6 +742,37 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                         )?;
                         return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
                     }
+                    // `class X extends DOMException` (undici's WebSocketError
+                    // and its module-init inheritability probe): `super(message,
+                    // name)` stamps the DOMException surface (`message`/`name`/
+                    // `code`) onto `this`. The X → DOMException registry edge
+                    // (registered at class-definition time) keeps `instanceof`.
+                    if parent_name.as_str() == "DOMException" {
+                        let undef = double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED));
+                        let mut lowered: Vec<String> = Vec::with_capacity(super_args.len());
+                        for a in super_args {
+                            lowered.push(lower_expr(ctx, a)?);
+                        }
+                        let arg0 = lowered.first().cloned().unwrap_or_else(|| undef.clone());
+                        let arg1 = lowered.get(1).cloned().unwrap_or_else(|| undef.clone());
+                        let this_box = match ctx.this_stack.last().cloned() {
+                            Some(slot) => ctx.block().load(DOUBLE, &slot),
+                            None => undef.clone(),
+                        };
+                        ctx.block().call(
+                            DOUBLE,
+                            "js_dom_exception_subclass_init",
+                            &[(DOUBLE, &this_box), (DOUBLE, &arg0), (DOUBLE, &arg1)],
+                        );
+                        let current_class_name =
+                            ctx.class_stack.last().cloned().unwrap_or_default();
+                        crate::lower_call::apply_field_initializers_recursive(
+                            ctx,
+                            &current_class_name,
+                            crate::lower_call::FieldInitMode::SelfOnly,
+                        )?;
+                        return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
+                    }
                     // `class X extends Promise` — `super(executor)` runs the
                     // ECMA-262 27.2.3.1 Promise constructor against a hidden
                     // backing `Promise` cell stashed on `this`. Inherited

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

@@ -38,6 +38,7 @@ pub(crate) enum NativeInstanceBase {
     Set,
     Event,
     CustomEvent,
+    DomException,
 }
 
 /// The native base a parent NAME denotes, if any.
@@ -56,6 +57,7 @@ pub(crate) fn native_instance_base(name: &str) -> Option<NativeInstanceBase> {
         "Set" => Some(NativeInstanceBase::Set),
         "Event" => Some(NativeInstanceBase::Event),
         "CustomEvent" => Some(NativeInstanceBase::CustomEvent),
+        "DOMException" => Some(NativeInstanceBase::DomException),
         _ => None,
     }
 }
@@ -170,6 +172,23 @@ pub(crate) fn emit_native_instance_base_init(
                 ],
             );
         }
+        NativeInstanceBase::DomException => {
+            // `super(message, name)` — both optional (`new DOMException()` is
+            // legal; the runtime defaults name to "Error").
+            let arg0 = lowered_args
+                .first()
+                .cloned()
+                .unwrap_or_else(|| undef.clone());
+            let arg1 = lowered_args
+                .get(1)
+                .cloned()
+                .unwrap_or_else(|| undef.clone());
+            ctx.block().call(
+                DOUBLE,
+                "js_dom_exception_subclass_init",
+                &[(DOUBLE, this_box), (DOUBLE, &arg0), (DOUBLE, &arg1)],
+            );
+        }
     }
 }
 

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

@@ -1264,6 +1264,13 @@ pub(crate) fn declare_phase_b_strings_part2(module: &mut LlModule) {
     );
     module.declare_function("js_custom_event_new", I64, &[DOUBLE, DOUBLE, I32]);
     module.declare_function("js_dom_exception_new", I64, &[DOUBLE, DOUBLE]);
+    // `super(message, name)` from `class X extends DOMException` — stamps the
+    // DOMException surface (`message`/`name`/`code`) onto the subclass `this`.
+    module.declare_function(
+        "js_dom_exception_subclass_init",
+        DOUBLE,
+        &[DOUBLE, DOUBLE, DOUBLE],
+    );
     module.declare_function("js_event_target_add_event_listener", VOID, &[I64, I64, I64]);
     module.declare_function(
         "js_event_target_add_event_listener_with_options",

crates/perry-ext-zlib/Cargo.toml

@@ -14,6 +14,12 @@ crate-type = ["staticlib", "rlib"]
 [dependencies]
 perry-ffi.workspace = true
 flate2 = "1"
+# zstd codecs: `zlib.zstdCompressSync` / `createZstdDecompress`. When `zlib`
+# routes here, perry-stdlib's `compression` module is compiled out — this
+# archive must carry the full zstd surface too, or programs whose compiled JS
+# references it (undici's web-fetch content decoding does, unconditionally)
+# die at link with undefined `js_zlib_*zstd*` symbols.
+zstd.workspace = true
 # Brotli stream + one-shot support (#1843). Matches the version the
 # `compression` feature pulls into perry-stdlib.
 brotli = "8.0.2"

crates/perry-ext-zlib/src/stream.rs

@@ -207,6 +207,72 @@ pub unsafe extern "C" fn js_zlib_brotli_decompress(data_value: f64, callback_val
     });
 }
 
+fn throw_zstd_error(err: &std::io::Error) -> ! {
+    perry_ffi::throw_with_code(&format!("zstd: {}", err), "Z_DATA_ERROR", ErrorKind::Error)
+}
+
+/// `zlib.zstdCompressSync(data)` -> Buffer. `_opts` is accepted (codegen
+/// passes the options slot through) but zstd params are not wired up —
+/// matches perry-stdlib's copy.
+///
+/// # Safety
+/// `data_value` is the raw NaN-boxed data argument (string or Buffer).
+#[no_mangle]
+pub unsafe extern "C" fn js_zlib_zstd_compress_sync(
+    data_value: f64,
+    _opts: f64,
+) -> *mut BufferHeader {
+    let data_bits = data_value.to_bits() as i64;
+    js_zlib_validate_buffer_arg(data_bits);
+    match read_input_from_bits(data_bits)
+        .map(|d| zstd::stream::encode_all(d.as_slice(), ZSTD_DEFAULT_LEVEL))
+    {
+        Some(Ok(out)) => alloc_buffer(&out),
+        Some(Err(e)) => throw_zstd_error(&e),
+        None => std::ptr::null_mut(),
+    }
+}
+
+/// `zlib.zstdDecompressSync(data)` -> Buffer.
+///
+/// # Safety
+/// `data_value` is the raw NaN-boxed data argument (string or Buffer).
+#[no_mangle]
+pub unsafe extern "C" fn js_zlib_zstd_decompress_sync(
+    data_value: f64,
+    _opts: f64,
+) -> *mut BufferHeader {
+    let data_bits = data_value.to_bits() as i64;
+    js_zlib_validate_buffer_arg(data_bits);
+    match read_input_from_bits(data_bits).map(|d| zstd::stream::decode_all(d.as_slice())) {
+        Some(Ok(out)) => alloc_buffer(&out),
+        Some(Err(e)) => throw_zstd_error(&e),
+        None => std::ptr::null_mut(),
+    }
+}
+
+/// `zlib.zstdCompress(data, callback)` -> undefined.
+///
+/// # Safety
+/// `data_value` and `callback_value` are raw NaN-boxed JS values.
+#[no_mangle]
+pub unsafe extern "C" fn js_zlib_zstd_compress(data_value: f64, callback_value: f64) {
+    queue_one_shot_callback(data_value, callback_value, "ZstdCompress", |b| {
+        zstd::stream::encode_all(b, ZSTD_DEFAULT_LEVEL)
+    });
+}
+
+/// `zlib.zstdDecompress(data, callback)` -> undefined.
+///
+/// # Safety
+/// `data_value` and `callback_value` are raw NaN-boxed JS values.
+#[no_mangle]
+pub unsafe extern "C" fn js_zlib_zstd_decompress(data_value: f64, callback_value: f64) {
+    queue_one_shot_callback(data_value, callback_value, "ZstdDecompress", |b| {
+        zstd::stream::decode_all(b)
+    });
+}
+
 // ── stream codec ─────────────────────────────────────────────────────────────
 
 #[derive(Clone, Copy)]
@@ -220,8 +286,15 @@ enum Codec {
     Unzip,
     BrotliCompress,
     BrotliDecompress,
+    ZstdCompress,
+    ZstdDecompress,
 }
 
+/// Node's `zlib` zstd default (matches perry-stdlib's copy). zstd levels run
+/// 1..=22 and don't share the deflate 0..=9 scale, so the `{ level }` option
+/// resolved by `js_zlib_resolve_level` is not applied to zstd codecs.
+const ZSTD_DEFAULT_LEVEL: i32 = 3;
+
 fn run_codec(codec: Codec, input: &[u8]) -> std::io::Result<Vec<u8>> {
     let mut out = Vec::new();
     match codec {
@@ -253,6 +326,8 @@ fn run_codec(codec: Codec, input: &[u8]) -> std::io::Result<Vec<u8>> {
         }
         Codec::BrotliCompress => out = brotli_compress_bytes(input),
         Codec::BrotliDecompress => out = brotli_decompress_bytes(input)?,
+        Codec::ZstdCompress => out = zstd::stream::encode_all(input, ZSTD_DEFAULT_LEVEL)?,
+        Codec::ZstdDecompress => out = zstd::stream::decode_all(input)?,
     }
     Ok(out)
 }
@@ -275,6 +350,8 @@ enum CodecState {
     DeflateDec(flate2::write::DeflateDecoder<Vec<u8>>),
     BrotliEnc(brotli::CompressorWriter<Vec<u8>>),
     BrotliDec(brotli::DecompressorWriter<Vec<u8>>),
+    ZstdEnc(zstd::stream::write::Encoder<'static, Vec<u8>>),
+    ZstdDec(zstd::stream::write::Decoder<'static, Vec<u8>>),
 }
 
 impl CodecState {
@@ -288,6 +365,8 @@ impl CodecState {
             CodecState::DeflateDec(w) => w.write_all(data),
             CodecState::BrotliEnc(w) => w.write_all(data),
             CodecState::BrotliDec(w) => w.write_all(data),
+            CodecState::ZstdEnc(w) => w.write_all(data),
+            CodecState::ZstdDec(w) => w.write_all(data),
         }
     }
 
@@ -301,6 +380,8 @@ impl CodecState {
             CodecState::DeflateDec(w) => w.flush(),
             CodecState::BrotliEnc(w) => w.flush(),
             CodecState::BrotliDec(w) => w.flush(),
+            CodecState::ZstdEnc(w) => w.flush(),
+            CodecState::ZstdDec(w) => w.flush(),
         }
     }
 
@@ -315,6 +396,8 @@ impl CodecState {
             CodecState::DeflateDec(w) => std::mem::take(w.get_mut()),
             CodecState::BrotliEnc(w) => std::mem::take(w.get_mut()),
             CodecState::BrotliDec(w) => std::mem::take(w.get_mut()),
+            CodecState::ZstdEnc(w) => std::mem::take(w.get_mut()),
+            CodecState::ZstdDec(w) => std::mem::take(w.get_mut()),
         }
     }
 
@@ -331,6 +414,14 @@ impl CodecState {
             // DecompressorWriter::into_inner returns Result<W, W> (Err on an
             // unterminated stream); take the decoded bytes either way.
             CodecState::BrotliDec(w) => Ok(w.into_inner().unwrap_or_else(|v| v)),
+            // Encoder::finish writes the zstd frame epilogue then hands back
+            // the inner Vec; Decoder::into_inner is tolerant of an
+            // unterminated frame (same stance as BrotliDec above).
+            CodecState::ZstdEnc(w) => w.finish(),
+            CodecState::ZstdDec(mut w) => {
+                w.flush()?;
+                Ok(w.into_inner())
+            }
         }
     }
 }
@@ -358,6 +449,15 @@ fn make_codec_state_with_level(codec: Codec, level: Compression) -> Option<Codec
         Codec::BrotliDecompress => {
             CodecState::BrotliDec(brotli::DecompressorWriter::new(Vec::new(), 4096))
         }
+        // zstd context allocation is fallible; `None` falls back to the same
+        // buffer-until-end `run_codec` path `createUnzip` uses, so a failed
+        // allocation degrades to one-shot semantics instead of erroring.
+        Codec::ZstdCompress => CodecState::ZstdEnc(
+            zstd::stream::write::Encoder::new(Vec::new(), ZSTD_DEFAULT_LEVEL).ok()?,
+        ),
+        Codec::ZstdDecompress => {
+            CodecState::ZstdDec(zstd::stream::write::Decoder::new(Vec::new()).ok()?)
+        }
         // Unzip auto-detects the header — kept buffer-until-end (run_codec).
         Codec::Unzip => return None,
     })
@@ -523,6 +623,8 @@ factory!(js_zlib_create_inflate_raw, Codec::InflateRaw, 8);
 factory!(js_zlib_create_unzip, Codec::Unzip, 8);
 factory!(js_zlib_create_brotli_compress, Codec::BrotliCompress, 0);
 factory!(js_zlib_create_brotli_decompress, Codec::BrotliDecompress, 0);
+factory!(js_zlib_create_zstd_compress, Codec::ZstdCompress, 0);
+factory!(js_zlib_create_zstd_decompress, Codec::ZstdDecompress, 0);
 
 // ── chunk / buffer helpers ─────────────────────────────────────────────────────
 
@@ -1346,6 +1448,15 @@ mod stream_tests {
         );
     }
 
+    #[test]
+    fn zstd_decoder_finish_flushes_pending_output() {
+        let expected = b"zstd decoder output buffered until the stream finishes";
+        let compressed = zstd::stream::encode_all(expected.as_slice(), ZSTD_DEFAULT_LEVEL).unwrap();
+        let mut decoder = make_codec_state(Codec::ZstdDecompress).expect("zstd decoder");
+        decoder.write_chunk(&compressed).unwrap();
+        assert_eq!(decoder.finish().unwrap(), expected);
+    }
+
     #[test]
     fn gunzip_run_codec_reads_all_members() {
         let a = stream_compress(Codec::Gzip, &[b"first "]);