fix: revert scope change, use simple parameter injection

Remove block-scope var destructuring mechanism — use original
function-parameter injection (new AsyncFunction(...keys, source))
to minimize risk.

getOctokit is added as a standard function parameter alongside
github, core, context, etc. The const/let redeclaration collision
is accepted as a documented trade-off in the major version bump.

Author: salmanmkc

__test__/async-function.test.ts

@@ -114,22 +114,6 @@ describe('callAsyncFunction', () => {
     await callAsyncFunction({} as any, 'console')
   })
 
-  test('const/let redeclaration of injected names does not throw', async () => {
-    const getOctokit = jest.fn().mockReturnValue('original')
-
-    // This would SyntaxError with the old function-parameter approach
-    const result = await callAsyncFunction(
-      {getOctokit} as any,
-      `
-        const getOctokit = () => 'shadowed'
-        return getOctokit()
-      `
-    )
-
-    expect(result).toEqual('shadowed')
-    expect(getOctokit).not.toHaveBeenCalled()
-  })
-
   test('injected names are accessible when not redeclared', async () => {
     const getOctokit = jest.fn().mockReturnValue('from-injected')
 
@@ -142,66 +126,6 @@ describe('callAsyncFunction', () => {
     expect(getOctokit).toHaveBeenCalledWith('token')
   })
 
-  test('return from block scope returns from function', async () => {
-    const result = await callAsyncFunction(
-      {foo: 'bar'} as any,
-      `return foo + '-baz'`
-    )
-
-    expect(result).toEqual('bar-baz')
-  })
-
-  test('top-level await works inside block scope', async () => {
-    const result = await callAsyncFunction(
-      {} as any,
-      `
-        const val = await Promise.resolve('async-value')
-        return val
-      `
-    )
-
-    expect(result).toEqual('async-value')
-  })
-
-  test('var redeclaration of injected names works (v8 compat)', async () => {
-    const getOctokit = jest.fn().mockReturnValue('original')
-
-    const result = await callAsyncFunction(
-      {getOctokit} as any,
-      `
-        var getOctokit = () => 'var-shadowed'
-        return getOctokit()
-      `
-    )
-
-    expect(result).toEqual('var-shadowed')
-    expect(getOctokit).not.toHaveBeenCalled()
-  })
-
-  test('reassignment of injected names works (v8 compat)', async () => {
-    const result = await callAsyncFunction(
-      {foo: 'original'} as any,
-      `
-        foo = 'reassigned'
-        return foo
-      `
-    )
-
-    expect(result).toEqual('reassigned')
-  })
-
-  test('rejects invalid argument names', () => {
-    expect(() =>
-      callAsyncFunction({'bad key': 'val'} as any, 'return 1')
-    ).toThrow('Invalid argument name: bad key')
-  })
-
-  test('rejects __scope__ as argument name', () => {
-    expect(() =>
-      callAsyncFunction({__scope__: 'val'} as any, 'return 1')
-    ).toThrow("'__scope__' is a reserved internal name")
-  })
-
   test('syntax errors in user code still throw', () => {
     expect(() => callAsyncFunction({} as any, 'const x = {')).toThrow(
       SyntaxError

dist/index.js

@@ -64946,23 +64946,8 @@ retry.VERSION = plugin_retry_dist_bundle_VERSION;
 ;// CONCATENATED MODULE: ./src/async-function.ts
 const AsyncFunction = Object.getPrototypeOf(async () => null).constructor;
 function callAsyncFunction(args, source) {
-    // Inject variables via var destructuring + block scope so that user
-    // scripts can shadow injected names with const/let (block-scoped) or
-    // var (function-scoped redeclaration) without SyntaxError.
-    // Using var (not const) preserves v8 reassignment semantics.
-    const keys = Object.keys(args);
-    // Guard: all keys must be valid JS identifiers (defensive for exported API)
-    const identRe = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-    for (const key of keys) {
-        if (!identRe.test(key)) {
-            throw new Error(`Invalid argument name: ${key}`);
-        }
-    }
-    if ('__scope__' in args) {
-        throw new Error("'__scope__' is a reserved internal name");
-    }
-    const fn = new AsyncFunction('__scope__', `var {${keys.join(', ')}} = __scope__;\n{\n${source}\n}`);
-    return fn(args);
+    const fn = new AsyncFunction(...Object.keys(args), source);
+    return fn(...Object.values(args));
 }
 
 ;// CONCATENATED MODULE: ./src/create-configured-getoctokit.ts

src/async-function.ts

@@ -23,26 +23,6 @@ export function callAsyncFunction<T>(
   args: AsyncFunctionArguments,
   source: string
 ): Promise<T> {
-  // Inject variables via var destructuring + block scope so that user
-  // scripts can shadow injected names with const/let (block-scoped) or
-  // var (function-scoped redeclaration) without SyntaxError.
-  // Using var (not const) preserves v8 reassignment semantics.
-  const keys = Object.keys(args)
-
-  // Guard: all keys must be valid JS identifiers (defensive for exported API)
-  const identRe = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/
-  for (const key of keys) {
-    if (!identRe.test(key)) {
-      throw new Error(`Invalid argument name: ${key}`)
-    }
-  }
-  if ('__scope__' in args) {
-    throw new Error("'__scope__' is a reserved internal name")
-  }
-
-  const fn = new AsyncFunction(
-    '__scope__',
-    `var {${keys.join(', ')}} = __scope__;\n{\n${source}\n}`
-  )
-  return fn(args)
+  const fn = new AsyncFunction(...Object.keys(args), source)
+  return fn(...Object.values(args))
 }