Specialize function wrappers by arity to avoid rest/spread on the hot path

Every Shen-level call went through a variadic (...args) wrapper that
allocates a rest array and re-spreads it, purely to support currying.
V8 partially optimizes this; JSC materializes the array every call,
making Bun ~2x slower than Node on call-heavy code despite comparable
raw-recursion speed.

funSync/funAsync now emit fixed-parameter wrappers for arities 0-4
(101/102 defuns in a shaken kernel), using arguments.length to detect
exact application and falling back to the extracted generic path for
partial/over/zero-arg application and arity > 4. Semantics preserved
branch-for-branch, including the arity:NaN quirk for partials of raw
closures; async wrappers remain AsyncFunction instances for fun's
dispatch and js.async?.

fib(32) standalone artifact, end-to-end: node 393->182 ms, bun
600->128 ms - bun now matches luajit (~130 ms) on this workload. All
suites green: backend 369, kernel 134/134, extensions, ratatoskr e2e,
frontend, bun smoke.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Reuben Brooks

lib/runtime.js

@@ -99,18 +99,66 @@ export default (options = {}) => {
     || isArray(x)  && isArray(y)  && x.length === y.length  && x.every((v, i) => equate(v, y[i]))
     || isObject(x) && isObject(y) && equateType(x, y)       && Object.keys(x).every(k => equate(x[k], y[k]));
 
+  // Generic (rest/spread) paths, only taken for partial application,
+  // over-application, zero-arg re-wrap, or arities above the specialization
+  // cutoff. The hot path - calling a wrapper with exactly `arity` arguments -
+  // goes through the fixed-parameter wrappers below, which avoid
+  // materializing a rest array on every call (a dominant cost on JSC and a
+  // measurable one on V8). `args` must be a real array here.
+  const funSyncGeneric = (f, arity, args) =>
+    args.length === arity ? f(...args) :
+    args.length > arity ? bounce(() => asFunction(settle(f(...args.slice(0, arity))))(...args.slice(arity))) :
+    args.length === 0 ? funSync(f, arity) :
+    Object.assign(funSync((...more) => f(...args, ...more), arity - args.length), { arity: f.arity - args.length });
+  const funAsyncGeneric = (f, arity, args) =>
+    args.length === arity ? f(...args) :
+    args.length > arity ? bounce(async () => asFunction(await settle(f(...args.slice(0, arity))))(...args.slice(arity))) :
+    args.length === 0 ? funAsync(f, arity) :
+    Object.assign(funAsync((...more) => f(...args, ...more), arity - args.length), { arity: f.arity - args.length });
+  // Arity-specialized wrappers: `function` (not arrow) so `arguments` is
+  // available to detect exact application without a rest parameter. `this`
+  // is unused throughout.
+  const slice = args => Array.prototype.slice.call(args);
+  const funSyncs = [
+    f => function () {
+      return arguments.length === 0 ? f() : funSyncGeneric(f, 0, slice(arguments));
+    },
+    f => function (a) {
+      return arguments.length === 1 ? f(a) : funSyncGeneric(f, 1, slice(arguments));
+    },
+    f => function (a, b) {
+      return arguments.length === 2 ? f(a, b) : funSyncGeneric(f, 2, slice(arguments));
+    },
+    f => function (a, b, c) {
+      return arguments.length === 3 ? f(a, b, c) : funSyncGeneric(f, 3, slice(arguments));
+    },
+    f => function (a, b, c, d) {
+      return arguments.length === 4 ? f(a, b, c, d) : funSyncGeneric(f, 4, slice(arguments));
+    }
+  ];
+  const funAsyncs = [
+    f => async function () {
+      return arguments.length === 0 ? f() : funAsyncGeneric(f, 0, slice(arguments));
+    },
+    f => async function (a) {
+      return arguments.length === 1 ? f(a) : funAsyncGeneric(f, 1, slice(arguments));
+    },
+    f => async function (a, b) {
+      return arguments.length === 2 ? f(a, b) : funAsyncGeneric(f, 2, slice(arguments));
+    },
+    f => async function (a, b, c) {
+      return arguments.length === 3 ? f(a, b, c) : funAsyncGeneric(f, 3, slice(arguments));
+    },
+    f => async function (a, b, c, d) {
+      return arguments.length === 4 ? f(a, b, c, d) : funAsyncGeneric(f, 4, slice(arguments));
+    }
+  ];
   const funSync = (f, arity) =>
-    (...args) =>
-      args.length === arity ? f(...args) :
-      args.length > arity ? bounce(() => asFunction(settle(f(...args.slice(0, arity))))(...args.slice(arity))) :
-      args.length === 0 ? funSync(f, arity) :
-      Object.assign(funSync((...more) => f(...args, ...more), arity - args.length), { arity: f.arity - args.length });
+    arity < funSyncs.length ? funSyncs[arity](f) :
+    (...args) => funSyncGeneric(f, arity, args);
   const funAsync = (f, arity) =>
-    async (...args) =>
-      args.length === arity ? f(...args) :
-      args.length > arity ? bounce(async () => asFunction(await settle(f(...args.slice(0, arity))))(...args.slice(arity))) :
-      args.length === 0 ? funAsync(f, arity) :
-      Object.assign(funAsync((...more) => f(...args, ...more), arity - args.length), { arity: f.arity - args.length });
+    arity < funAsyncs.length ? funAsyncs[arity](f) :
+    async (...args) => funAsyncGeneric(f, arity, args);
   const fun = (f, arity = f.arity || f.length) =>
     Object.assign((f instanceof AsyncFunction ? funAsync : funSync)(f, arity), { arity });