Add configurable runner module to py_asgi:run/5

- py_asgi.erl: Extract runner option from Opts, default to hornbeam_asgi_runner
- py_nif.erl: Change asgi_run/4 to asgi_run/5 with Runner as first param
- py_asgi.c: Accept runner module as argv[0], use dynamic import instead of hardcoded module name
- py_nif.c: Update NIF table arity from 4 to 5

This allows different ASGI runner implementations to be used with the
optimized NIF marshalling path.

Author: benoitc

c_src/py_asgi.c

@@ -1123,7 +1123,7 @@ static ERL_NIF_TERM nif_asgi_build_scope(ErlNifEnv *env, int argc, const ERL_NIF
 }
 
 static ERL_NIF_TERM nif_asgi_run(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
-    if (argc < 4) {
+    if (argc < 5) {
         return make_error(env, "badarg");
     }
 
@@ -1135,23 +1135,28 @@ static ERL_NIF_TERM nif_asgi_run(ErlNifEnv *env, int argc, const ERL_NIF_TERM ar
         return make_error(env, "asgi_not_initialized");
     }
 
-    ErlNifBinary module_bin, callable_bin;
+    ErlNifBinary runner_bin, module_bin, callable_bin;
 
-    if (!enif_inspect_binary(env, argv[0], &module_bin)) {
+    if (!enif_inspect_binary(env, argv[0], &runner_bin)) {
+        return make_error(env, "invalid_runner");
+    }
+    if (!enif_inspect_binary(env, argv[1], &module_bin)) {
         return make_error(env, "invalid_module");
     }
-    if (!enif_inspect_binary(env, argv[1], &callable_bin)) {
+    if (!enif_inspect_binary(env, argv[2], &callable_bin)) {
         return make_error(env, "invalid_callable");
     }
 
     PyGILState_STATE gstate = PyGILState_Ensure();
 
     ERL_NIF_TERM result;
 
-    /* Convert module and callable names */
+    /* Convert runner, module and callable names */
+    char *runner_name = binary_to_string(&runner_bin);
     char *module_name = binary_to_string(&module_bin);
     char *callable_name = binary_to_string(&callable_bin);
-    if (module_name == NULL || callable_name == NULL) {
+    if (runner_name == NULL || module_name == NULL || callable_name == NULL) {
+        enif_free(runner_name);
         enif_free(module_name);
         enif_free(callable_name);
         PyGILState_Release(gstate);
@@ -1174,24 +1179,24 @@ static ERL_NIF_TERM nif_asgi_run(ErlNifEnv *env, int argc, const ERL_NIF_TERM ar
     }
 
     /* Build optimized scope dict from Erlang map */
-    PyObject *scope = asgi_scope_from_map(env, argv[2]);
+    PyObject *scope = asgi_scope_from_map(env, argv[3]);
     if (scope == NULL) {
         Py_DECREF(asgi_app);
         result = make_py_error(env);
         goto cleanup;
     }
 
     /* Convert body binary */
-    PyObject *body = asgi_binary_to_buffer(env, argv[3]);
+    PyObject *body = asgi_binary_to_buffer(env, argv[4]);
     if (body == NULL) {
         Py_DECREF(scope);
         Py_DECREF(asgi_app);
         result = make_py_error(env);
         goto cleanup;
     }
 
-    /* Import the ASGI runner from hornbeam */
-    PyObject *runner_module = PyImport_ImportModule("hornbeam_asgi_runner");
+    /* Import the ASGI runner module */
+    PyObject *runner_module = PyImport_ImportModule(runner_name);
     if (runner_module == NULL) {
         /* Fallback: try to run ASGI app directly with asyncio.run */
         PyErr_Clear();
@@ -1213,11 +1218,11 @@ static ERL_NIF_TERM nif_asgi_run(ErlNifEnv *env, int argc, const ERL_NIF_TERM ar
         Py_DECREF(body);
         Py_DECREF(scope);
         Py_DECREF(asgi_app);
-        result = make_error(env, "hornbeam_asgi_runner_required");
+        result = make_error(env, "runner_module_required");
         goto cleanup;
     }
 
-    /* Call run_asgi(module_name, callable_name, scope, body) */
+    /* Call _run_asgi_sync(module_name, callable_name, scope, body) */
     PyObject *run_result = PyObject_CallMethod(
         runner_module, "_run_asgi_sync", "ssOO",
         module_name, callable_name, scope, body);
@@ -1239,6 +1244,7 @@ static ERL_NIF_TERM nif_asgi_run(ErlNifEnv *env, int argc, const ERL_NIF_TERM ar
     result = enif_make_tuple2(env, ATOM_OK, term_result);
 
 cleanup:
+    enif_free(runner_name);
     enif_free(module_name);
     enif_free(callable_name);
     PyGILState_Release(gstate);

c_src/py_asgi.h

@@ -470,12 +470,12 @@ static PyObject *asgi_scope_from_map(ErlNifEnv *env, ERL_NIF_TERM scope_map);
  * - Uses response pooling
  * - Runs ASGI app coroutine synchronously
  *
- * NIF signature: py_asgi:run(AppModule, AppCallable, ScopeMap, BodyBinary) ->
+ * NIF signature: py_asgi:run(Runner, AppModule, AppCallable, ScopeMap, BodyBinary) ->
  *                  {ok, {Status, Headers, Body}} | {error, Reason}
  *
  * @param env NIF environment
- * @param argc Argument count (must be 4)
- * @param argv [AppModule, AppCallable, ScopeMap, BodyBinary]
+ * @param argc Argument count (must be 5)
+ * @param argv [Runner, AppModule, AppCallable, ScopeMap, BodyBinary]
  * @return Result tuple
  */
 static ERL_NIF_TERM nif_asgi_run(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);

c_src/py_nif.c

@@ -1870,7 +1870,7 @@ static ErlNifFunc nif_funcs[] = {
 
     /* ASGI optimizations */
     {"asgi_build_scope", 1, nif_asgi_build_scope, ERL_NIF_DIRTY_JOB_IO_BOUND},
-    {"asgi_run", 4, nif_asgi_run, ERL_NIF_DIRTY_JOB_IO_BOUND}
+    {"asgi_run", 5, nif_asgi_run, ERL_NIF_DIRTY_JOB_IO_BOUND}
 };
 
 ERL_NIF_INIT(py_nif, nif_funcs, load, NULL, upgrade, unload)

src/py_asgi.erl

@@ -153,10 +153,10 @@ run(Module, Callable, Scope, Body) ->
 %% @returns {ok, {Status, Headers, Body}} on success
 -spec run(binary(), binary(), scope(), binary(), map()) ->
     {ok, {integer(), [{binary(), binary()}], binary()}} | {error, term()}.
-run(Module, Callable, Scope, Body, _Opts) ->
-    %% Ensure scope has required ASGI fields
+run(Module, Callable, Scope, Body, Opts) ->
+    Runner = maps:get(runner, Opts, <<"hornbeam_asgi_runner">>),
     FullScope = ensure_scope_defaults(Scope),
-    py_nif:asgi_run(Module, Callable, FullScope, Body).
+    py_nif:asgi_run(Runner, Module, Callable, FullScope, Body).
 
 %% @doc Build an optimized Python scope dict.
 %%

src/py_nif.erl

@@ -114,7 +114,7 @@
     set_python_event_loop/1,
     %% ASGI optimizations
     asgi_build_scope/1,
-    asgi_run/4
+    asgi_run/5
 ]).
 
 -on_load(load_nif/0).
@@ -762,13 +762,14 @@ asgi_build_scope(_ScopeMap) ->
 %% which provides the `_run_asgi_sync` function that handles the
 %% ASGI receive/send protocol.
 %%
+%% @param Runner Python runner module name (e.g., <<"hornbeam_asgi_runner">>)
 %% @param Module Application module name (e.g., <<"myapp.asgi">>)
 %% @param Callable ASGI callable name (e.g., <<"application">>)
 %% @param ScopeMap Erlang map containing ASGI scope (see asgi_build_scope/1)
 %% @param Body Request body as binary
 %% @returns {ok, {Status, Headers, Body}} on success,
 %%          or {error, Reason}
--spec asgi_run(binary(), binary(), map(), binary()) ->
+-spec asgi_run(binary(), binary(), binary(), map(), binary()) ->
     {ok, {integer(), [{binary(), binary()}], binary()}} | {error, term()}.
-asgi_run(_Module, _Callable, _ScopeMap, _Body) ->
+asgi_run(_Runner, _Module, _Callable, _ScopeMap, _Body) ->
     ?NIF_STUB.