post-#652: CJS module.exports = Class + extends still drops methods (rate-limiter-flexible repro)

[proggeramlug]

Following up on #652 (closed in v0.5.795 via dee8659): the ESM export class shape is now fixed — @perryts/mysql's Pool instantiates and pool.query(...) is a function. But the CJS module.exports = Class + extends shape still crashes:

TypeError: value is not a function
    at <anonymous>

Hit this trying to use rate-limiter-flexible's RateLimiterMemory from a Perry-compiled native server: every method on the instance is undefined (typeof limiter.consume === "undefined"), and our request handler crashes with the TypeError above before any HTTP body is written.

Reproducer (3 files, total ~12 lines of code)

// /tmp/cjs-class/base.js
class Base {
  greetBase(n) { return "base:" + n; }
}
module.exports = Base;

// /tmp/cjs-class/child.js
const Base = require('./base');
class Child extends Base {
  constructor(opts) { super(opts); this.opts = opts; }
  greetChild(n) { return "child:" + n; }
}
module.exports = Child;

// /tmp/cjs-class/main.ts
const Child = require('./child');
async function main() {
  const c = new Child({ x: 1 });
  console.log("typeof c.greetChild:", typeof c.greetChild);
  console.log("typeof c.greetBase:",  typeof c.greetBase);
  if (typeof c.greetChild === "function") console.log(c.greetChild("hi"));
  if (typeof c.greetBase  === "function") console.log(c.greetBase("hi"));
}
main().catch((e) => { console.error(e); process.exit(2); });

$ perry compile main.ts -o probe && ./probe
TypeError: value is not a function
    at <anonymous>
$ echo $?
1

The crash fires during new Child({ x: 1 }) itself — before either typeof log can run. So it's not just the methods that vanish; the construction path bails too. Same code under tsx main.ts works correctly:

$ npx tsx main.ts
typeof c.greetChild: function
typeof c.greetBase:  function
child:hi
base:hi

Difference from the original #652 case

@perryts/mysql's Pool is an ESM module: import { connect } from './connection'; export class Pool { ... } with bare class fields and no inheritance. dee8659's cjs_wrap fix unblocked that.

rate-limiter-flexible's RateLimiterMemory (and the published shape of many older npm packages) is CommonJS:

const RateLimiterAbstract = require('./RateLimiterAbstract');
class RateLimiterMemory extends RateLimiterAbstract {
  constructor(opts = {}) { super(opts); ... }
  consume(key, ...) { ... }
}
module.exports = RateLimiterMemory;

Three things stack here that the ESM repro didn't have:

1. module.exports = Class (single-export, no destructuring on the consumer side)
2. class … extends Base
3. require('./relative-cjs-file') returning the bare class

Any one of those may be the trigger; they appear together in rate-limiter-flexible's output.

Discovery context

Native server boots through migrations + crypto KID + listening (#609 + #639 + #652 ESM-class fix all good ✓), serves /healthz / /readyz / /metrics correctly, but the very first POST /v1/auth/signup dies in our rate-limit middleware:

await signupLimiter.consume(ipKey(req, "signup"));   // ← TypeError here

signupLimiter is new RateLimiterMemory({...}). With the precompiled-CJS instance methods missing, .consume is undefined.

Same code under tsx server/main.ts runs the entire 24-suite e2e green. Only the perry-compiled native binary path fails.

Environment

• perry 0.5.795 (target/release perry-runtime + perry-stdlib rebuilt from dee86595)
• rate-limiter-flexible@5.0.x (precompiled CJS in node_modules)
• --target macos, arm64

Why we filed

After your dee8659 ESM-class fix, the native server made it all the way through boot for the first time — major progress. This CJS variant blocks it on the very first authed request. Once it lands, every other CJS-published npm package's classes (most of the ecosystem) becomes usable from Perry-compiled binaries.

[proggeramlug]

Re-tested against perry 0.5.803 (target/release perry-runtime + perry-stdlib rebuilt this morning from the 0.5.798/0.5.800 chain). The fix titles describe "default-imported-class" — which matches import Default from "…" syntax — but my original repros don't use that import shape, and both still fail identically:

Repro 1: minimal CJS class + extends, via require()

Exactly the 12-line reproducer from the original filing:

// base.js
class Base { greetBase(n) { return "base:" + n; } }
module.exports = Base;

// child.js
const Base = require('./base');
class Child extends Base {
  constructor(opts) { super(opts); this.opts = opts; }
  greetChild(n) { return "child:" + n; }
}
module.exports = Child;

// main.ts
const Child = require('./child');
const c = new Child({ x: 1 });
console.log("typeof c.greetChild:", typeof c.greetChild);

$ perry compile main.ts -o probe && ./probe
TypeError: value is not a function
    at <anonymous>
$ echo $?
1

Crash at new Child({ x: 1 }) — same as pre-fix.

Repro 2: real-world named import of RateLimiterMemory

import { RateLimiterMemory } from "rate-limiter-flexible";
const limiter = new RateLimiterMemory({ points: 3, duration: 60 });
console.log("typeof limiter.consume:", typeof limiter.consume);
console.log("Object.keys(limiter):",  Object.keys(limiter).join(","));

$ perry compile probe.ts -o rl-probe && ./rl-probe
typeof limiter.consume: undefined
Object.keys(limiter):

Pre-fix and post-fix output is byte-identical.

What might explain the gap

If v0.5.798/0.5.800 narrowed the fix to import DefaultClass from "cjs-mod" specifically — the shape where TypeScript's interop helper wraps a CJS module.exports = Class into a default import — neither of these cases would have hit the fixed path. Our cases are:

• const X = require(...) (Repro 1) — bare CJS require, no TS interop
• import { X } from "..." (Repro 2) — named import from a CJS package that uses module.exports = OneClass, which TS resolves through synthetic default-export interop in some configs but not others

In our server's tsconfig (and presumably most npm consumers): "esModuleInterop": true, "allowSyntheticDefaultImports": true. With those, import { RateLimiterMemory } from "rate-limiter-flexible" should round-trip identically to a default-import for a CJS module that has only one named-ish export. But on Perry-compiled, the result has no prototype methods.

Downstream impact (still blocking native server boot)

The server's auth path uses await signupLimiter.consume(...) where signupLimiter is the broken instance — first POST /v1/auth/signup against the native binary still crashes with TypeError: value is not a function. Boot reaches Server listening on http://0.0.0.0:18080 cleanly thanks to #609 + #639 + #652 ESM-class fix, then dies on the first request.

Reopening attention here rather than filing a third focused issue. Happy to refile if you'd prefer a fresh ticket with a name like "named-import of CJS-module.exports class drops prototype methods".

Environment

• perry 0.5.803 (target/release built from c5adb488-or-later this session)
• rate-limiter-flexible precompiled CJS (the published shape)
• --target macos, arm64

[proggeramlug]

Re-tested at perry 0.5.809 (target/release rebuilt this session, includes 331f7136 fix(cjs-wrap): refs #665 — forward class identity through exports.X = require('./Y') index aggregators (v0.5.808)).

Two distinct outcomes:

My minimal require() repro is now a deliberate compile-time error (good)

Perry now refuses to compile bare const X = require('./Y') from a .ts entry, with a clean error pointing to #668:

Error: CommonJS `require("./child")` is not supported under `perry compile` —
use a static `import` instead (e.g. `import * as m from "./child"` or
`import { x } from "./child"`). Closes #668.

That's a sensible developer-side resolution. My original 12-line repro was artificial; users would always write import { X } from "..." in .ts source. So that path is closed.

The real-world import { RateLimiterMemory } from "rate-limiter-flexible" still drops methods

import { RateLimiterMemory } from "rate-limiter-flexible";
const limiter = new RateLimiterMemory({ points: 3, duration: 60 });
console.log("typeof limiter.consume:", typeof limiter.consume);  // → undefined

Build + run unchanged from prior recheck. The package's index.js (its main per package.json) is two layers deep:

Layer 1 — node_modules/rate-limiter-flexible/index.js:

const RateLimiterMemory = require('./lib/RateLimiterMemory');
const RateLimiterRedis  = require('./lib/RateLimiterRedis');
// ... 13 more imports
module.exports = {
  RateLimiterRedis,
  RateLimiterMemory,
  // ... rest spread into object literal
};

Layer 2 — node_modules/rate-limiter-flexible/lib/RateLimiterMemory.js:

const RateLimiterAbstract = require('./RateLimiterAbstract');
class RateLimiterMemory extends RateLimiterAbstract {
  constructor(opts = {}) { super(opts); this._memoryStorage = new MemoryStorage(); }
  consume(key, pointsToConsume = 1, options = {}) { /* ... */ }
}
module.exports = RateLimiterMemory;

So the user's import { RateLimiterMemory } from "rate-limiter-flexible" resolves to Layer 1, which uses bare-require + object-literal aggregation (different from the exports.X = require('./Y') shape that 0.5.808 fixed). Layer 2 itself uses extends + module.exports = OneClass.

Three things stack here that I don't think 0.5.808 covers:

1. Aggregator file's module.exports = { X, Y, Z } (object literal, not property assignment)
2. Each entry is const X = require('./lib/X') (bare require, not exports.X = ...)
3. The leaf module is class extends Other { ... }; module.exports = Class

Same code under tsx server/main.ts works. Native binary boots through migrations + Server listening, then dies on the first request that touches signupLimiter.consume(...).

Discovery context (unchanged from prior recheck)

Native server's POST /v1/auth/signup rate-limit middleware does await signupLimiter.consume(ipKey(req, "signup")). With signupLimiter.consume === undefined, await undefined(...) becomes TypeError: value is not a function and crashes the process before any HTTP body is written.

Happy to refile as a focused issue named something like "named import of CJS module.exports = { Class, … } object-literal aggregator drops prototype methods" if you want to keep the scopes separate. Continues to be the only thing blocking the native server's first authed request after #609 + #639 + #652 + #640 all landed.

[proggeramlug]

Fixed in v0.5.836 (commit e84cf67). The CJS wrap now detects const X = require('./lib/X'); module.exports = { X, Y }; object-literal aggregators (rate-limiter-flexible shape) and emits export { _req_N as X }; direct-reexports instead of export const X = _cjs.X; property reads — class identity propagates through compile.rs's Export::Named arm and prototype methods land on instances.

Validated with a 3-file repro modeling the rate-limiter-flexible aggregator shape (index.js → lib/Child.js extends Base): typeof c.greetChild: function, typeof c.greetBase: function, methods runnable — byte-identical to npx tsx. Six new unit tests in cjs_wrap::tests cover shorthand, longhand, mixed-with-skipped-entries, no-require-aliases-fallthrough, last-assignment-wins, and end-to-end wrap emit.

Out of scope. Surfaced a separate super(opts) field-propagation gap when the parent constructor does this.X = opts.X and the child calls super(...) — fields don't land on this. Pre-existing inheritance bug independent of #665's class-identity-forwarding ask; worth its own focused issue.

[proggeramlug]

Re-tested at perry 0.5.836 (the very commit e84cf67d fix(cjs-wrap): #665 forward class identity through object-literal aggregators (v0.5.836)) — both perry-runtime and perry-stdlib rebuilt fresh, .perry-cache and build/ wiped between runs.

The fix isn't taking. Behavior is unchanged in the real-world case and worse in the minimal case.

Minimal standalone repro (please reopen — this segfaults)

No extends, no transitive requires, single object-literal aggregator. Drop these four files into a fresh directory and perry compile main.ts -o probe:

package.json

{ "name": "rlf-shape", "private": true, "version": "0.0.0" }

node_modules/rlfshape/package.json

{ "name": "rlfshape", "version": "0.0.0", "main": "index.js" }

node_modules/rlfshape/index.js — the object-literal aggregator (this is the pattern v0.5.836 claims to fix):

const Other = require('./lib/Other');
module.exports = { Other };

node_modules/rlfshape/lib/Other.js — plain CJS class, no extends:

class Other {
  constructor(opts = {}) { this._x = opts.x || 1; }
  hello() { return "hi from " + this._x; }
}
module.exports = Other;

main.ts (entry):

import { Other } from "rlfshape";
const o = new Other({ x: 99 });
console.log("typeof o:", typeof o);
console.log("Object.keys(o):", Object.keys(o as object).join(","));
console.log("typeof o.hello:", typeof (o as { hello?: unknown }).hello);

Observed under perry 0.5.836

$ perry compile main.ts -o probe
Wrote executable: probe
$ ./probe
typeof o: undefined
[1]    SIGSEGV   ./probe

new Other(...) returns undefined, then the next line dereferences it. Segfault.

tsx baseline (truth)

$ tsx main.ts
typeof o: object
Object.keys(o): _x
typeof o.hello: function
o.hello(): hi from 99

Real-world rate-limiter-flexible is also unfixed

Same probe as before, no changes:

import { RateLimiterMemory } from "rate-limiter-flexible";
const limiter = new RateLimiterMemory({ points: 3, duration: 60 });
console.log("typeof limiter:", typeof limiter);
console.log("Object.keys(limiter):", Object.keys(limiter).join(","));
console.log("typeof limiter.consume:", typeof limiter.consume);

typeof limiter: object
Object.keys(limiter):
typeof limiter.consume: undefined

Different surface (object vs undefined), but same underlying break: the user-defined constructor() body never runs (no own properties materialize) and prototype methods aren't reachable.

Diff between the two cases

Aspect	Minimal rlfshape	Real rate-limiter-flexible
new X(...) result	undefined (segfault on next access)	object (empty own props)
extends in leaf	No	Yes (extends RateLimiterAbstract)
Aggregator file size	2 lines	33 lines, 15 requires
Aggregator pattern	module.exports = { X }	module.exports = { X, Y, Z, ... }

Both should produce a fully-constructed instance with prototype methods. Neither does after v0.5.836.

Diagnostic

Native server still crashes with TypeError: value is not a function at the first signupLimiter.consume(...) call — exactly as in the prior re-tests. Continues to be the sole blocker for ./build/server (native, perry-compiled) servicing any authenticated route, after #609 + #639 + #652 + #640 all landed cleanly.

Happy to file separately if the minimal-case typeof: undefined segfault is a distinct bug. From the user's perspective it's all "named import of CJS class through module.exports = { Class, ... } aggregator returns garbage."

[proggeramlug]

Real fix landed in v0.5.839 (commit d51f6c74). The diagnosis turned out to be a different bug than the previous three rounds tried to fix.

What was actually broken

Your minimal rlfshape repro and the real rate-limiter-flexible both reduce to the same pattern at the wrap level: a child class extends an imported parent across cjs-wrapped modules. v0.5.836 correctly forwarded class identity through module.exports = { X, Y } aggregators, so new Other(...) resolved to the right constructor. But the child's super(opts) call silently no-op'd whenever the parent was imported — the parent's constructor body never ran, so any fields it would set (this.points = opts.points, etc.) showed up as undefined-valued keys on the instance.

Root cause: cjs_wrap emitted import _req_0 from './X'; const RateLimiterAbstract = _req_0; for the IIFE's var RateLimiterAbstract = require('./X') line. The const alias was invisible to compile.rs's imported_class_ctors registration (which keyed on the import local _req_0, not the const alias RateLimiterAbstract). HIR sets the child's extends_name = "RateLimiterAbstract", codegen's super-call dispatch at expr.rs:5094 looked up that name in ctx.classes, missed, and fell through to the no-parent-in-ctx branch which returns TAG_UNDEFINED without invoking any ctor.

The fix

crates/perry/src/commands/compile/cjs_wrap.rs: when a CJS source has a unique var/const/let X = require('Y') alias and X is a safe identifier (not _cjs/module/exports/require/_req_* and not a hoisted class name), use X as the import local name directly — import X from 'Y' — instead of the _req_N placeholder + separate const-alias line. compile.rs's default-import handler then registers imported_class_ctors[X], codegen's stub-class builder registers ctx.classes[X], and the super-call dispatch's parent lookup succeeds → falls into the existing imported-class-ctor branch which calls the source module's standalone perry_<srcprefix>__X_constructor symbol. That standalone ctor itself runs apply_field_initializers_recursive_pub, so parent-class arrow-field initializers also land on this. First safe alias per spec wins; subsequent aliases keep their const X = <chosen>; form.

Validation

Your exact third-rerun rlfshape probe ({rlfshape/{package.json,index.js,lib/Other.js},package.json,main.ts} with compilePackages: ["rlfshape"]):

typeof o: object
Object.keys(o): _x
typeof o.hello: function
hello: hi from 99
exit=0

Byte-identical to tsx main.ts. The pre-fix segfault and typeof o: undefined are gone.

Same repro plus extends (RateLimiterMemory ← RateLimiterAbstract shape with constructor-body field assignment):

[Abstract.ctor] opts: {"points":3,"duration":60}
[Abstract.ctor] after this.points= 3
[Abstract.ctor] after this.duration= 60
[Memory.ctor] after super, this.points= 3
consume: consume:ip:1.2.3.4:3
describe: abstract:3/60

Parent constructor now runs, fields land on this, method bodies see them.

What's still ahead for real rate-limiter-flexible

I ran import { RateLimiterMemory } from "rate-limiter-flexible" against the real npm package post-fix. Major progress: parent constructor body now runs, super(opts) is no longer a no-op, limiter.consume is reachable. But RateLimiterAbstract uses getter/setter pairs (get points() { return this._points } / set points(v) { this._points = v >= 0 ? v : 4 }) — cross-module accessor dispatch for imported classes isn't yet wired. So limiter.points reads as 0 instead of 3, and consume() short-circuits because res.consumedPoints > this.points is always true when this.points == 0. That's a distinct bug — getter/setter dispatch across imported parents — and worth a separate focused issue. The super() no-op gap that this commit closes is the one #665 was titled around.

Available in v0.5.839 (d51f6c74). Let me know if you'd like me to file the follow-up issue for the getter/setter dispatch gap once you've re-tested.

[proggeramlug]

Thanks for the v0.5.839 fix and the detailed root-cause writeup — confirmed that side of the bug is gone. But the real rate-limiter-flexible is still broken, and I now have a tight bisect on the residual gap. It's not the cross-module accessor dispatch you flagged, it's a narrower variant of the same super() no-op you just patched.

First, two pieces of out-of-band setup that bit me

1. My probes were inert against the v0.5.836 and v0.5.839 fixes because compilePackages was absent from the project's package.json. Without it, cjs_wrap doesn't run on the package at all and the named import returns a partly-constructed object. Adding "perry": { "compilePackages": ["rate-limiter-flexible"] } (or ["rlfshape"] for the minimal) is the gate.
2. With that gate in place, my minimal rlfshape repro from the last comment now passes byte-identical to tsx — exactly as you reported. Parent constructor runs, parent-set fields land on this, prototype methods reachable. v0.5.839 is doing what it claims.

So the previous "fix isn't taking" report on my end was 50% "fix isn't taking on the real package" and 50% "I never opted in." Apologies for the noise on the latter half.

The residual gap (still broken at v0.5.839)

The real rate-limiter-flexible/lib/RateLimiterAbstract.js doesn't use the declaration form. It uses the class-expression form:

// node_modules/rate-limiter-flexible/lib/RateLimiterAbstract.js
module.exports = class RateLimiterAbstract {
  constructor(opts = {}) {
    this.points = opts.points;       // triggers setter
    this.duration = opts.duration;   // triggers setter
    // ...
  }
  get points() { return this._points; }
  set points(value) { this._points = value >= 0 ? value : 4; }
  // ...
};

vs. the declaration form your v0.5.839 fix targets:

class RateLimiterAbstract { ... }
module.exports = RateLimiterAbstract;

Same child shape (class Memory extends RateLimiterAbstract { constructor(o){ super(o); this._mem = ... } }) — super() works for the declaration form, no-ops for the expression form.

Minimal bisect

Drop into a fresh dir with package.json containing "perry": { "compilePackages": ["rlfshape"] }. Same main3.ts, same child Memory.js (extends Abstract, super(opts), this._mem = ...). Only the parent file changes between the two probes:

lib/Abstract.js — declaration form (v0.5.839 fixes this):

class Abstract {
  constructor(opts = {}) { this.points = opts.points; this.duration = opts.duration; }
  get points() { return this._points; }
  set points(v) { this._points = v >= 0 ? v : 4; }
  get duration() { return this._duration; }
  set duration(v) { this._duration = typeof v === 'undefined' ? 1 : v; }
}
module.exports = Abstract;

Output:

Object.keys(m): _points,_mem   ← parent setter ran, child ran
m.points (via getter): 7        ← matches tsx

lib/Abstract.js — expression form (v0.5.839 still broken):

module.exports = class Abstract {
  constructor(opts = {}) { this.points = opts.points; this.duration = opts.duration; }
  get points() { return this._points; }
  set points(v) { this._points = v >= 0 ? v : 4; }
  get duration() { return this._duration; }
  set duration(v) { this._duration = typeof v === 'undefined' ? 1 : v; }
};

Output:

Object.keys(m): _mem            ← only child ctor ran; parent body did NOT
m.points (via getter): undefined

Diff is literally one line at top of Abstract.js (class Abstract { vs module.exports = class Abstract {) plus the trailing module.exports = Abstract; line.

typeof m.consume === "function" in both cases — prototype identity forwards fine. So your prior diagnosis ("super-call dispatch falls through to no-parent-in-ctx branch") seems to be exactly what's still happening for the class-expression case. I'd guess cjs_wrap's "unique const X = require('Y') → import X from 'Y' direct alias" rule fires for declaration-form parents but doesn't kick in when the parent module's module.exports is an anonymous-or-named expression that doesn't surface a top-level binding for compile.rs to register imported_class_ctors against.

Real package still down

limiter.consume === undefined (Object.keys empty) under the real rate-limiter-flexible because RateLimiterAbstract exports via the expression form. Server still crashes with the same TypeError: value is not a function at the first signupLimiter.consume(...). The accessor-dispatch concern you mentioned doesn't show up in my isolated minimal — getters work fine with declaration-form parents — so I think this expression-form gap is upstream of any getter/setter problem.

Happy to file as a fresh issue if you'd rather track this separately from #665 (super() across cjs-wrapped modules when parent exports a class expression).