gh-147: IMPORT_PATH exposes imported module-restricted extension operators through alias.

Author: python-processing-unit

src/builtins.c

@@ -7456,10 +7456,17 @@ static int module_export_bindings(Interpreter* interp, Env* caller_env, Env* mod
             size_t ns_len = (size_t)(cursor - start);
             if (ns_len == 0) continue;
 
-            char* ns = malloc(ns_len + 1);
-            if (!ns) return -1;
-            memcpy(ns, start, ns_len);
-            ns[ns_len] = '\0';
+                char* ns = malloc(ns_len + 1);
+                if (!ns) return -1;
+                memcpy(ns, start, ns_len);
+                ns[ns_len] = '\0';
+
+                /* Ensure any module-restricted extension operators registered
+                    by the loaded extension are exposed under the importing
+                    module's alias so callers can call alias.ext.NAME. */
+                char* ext_err = NULL;
+                (void)extensions_expose_named(ns, alias, &ext_err);
+                if (ext_err) { free(ext_err); ext_err = NULL; }
 
             size_t ns_qual_len = alias_len + 1 + ns_len + 1;
             char* ns_qualified = malloc(ns_qual_len);

src/extensions.c

@@ -776,6 +776,22 @@ int extensions_load_named(const char* spec,
     return rc;
 }
 
+int extensions_expose_named(const char* ext_name, const char* scope_name, char** error_out) {
+    if (!ext_name || ext_name[0] == '\0') {
+        set_error(error_out, "extensions_expose_named: empty extension name");
+        return -1;
+    }
+
+    for (LoadedExtension* le = g_loaded; le; le = le->next) {
+        if (exposure_exists(le, ext_name)) {
+            return extension_register_exposure(le, ext_name, scope_name, error_out);
+        }
+    }
+
+    set_errorf(error_out, "Extension not loaded: ", ext_name);
+    return -1;
+}
+
 void extensions_shutdown(void) {
     LoadedExtension* e = g_loaded;
     while (e) {

src/extensions.h

@@ -26,6 +26,12 @@ int extensions_load_named(const char* spec,
                           char** loaded_name_out,
                           char** error_out);
 
+// Ensure a previously-loaded extension is exposed under the provided
+// scope_name (module alias). This creates scope-qualified aliases for any
+// operators registered with the module-restriction flag. Returns 0 on
+// success, -1 on failure; on failure *error_out is heap-allocated.
+int extensions_expose_named(const char* ext_name, const char* scope_name, char** error_out);
+
 // Unload all loaded extension libraries.
 void extensions_shutdown(void);