gh-92: Replace .prex with EXTEND.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -664,9 +664,9 @@
 
 ---
 
-### 8.2 Extensions and pointer files
+### 8.2 Extensions and `EXTEND`
 
-The interpreter MAY accept zero or more extension arguments before the program argument. Extensions MUST be loaded before parsing so that extension-defined type names, operators, and hooks are available during parse and execution.
+The interpreter MAY accept zero or more compiled extension-library arguments before the program argument. Those libraries MUST be loaded before parsing so that extension-defined operators and hooks are available during parse and execution.
 
 A compiled extension MUST be a platform-specific dynamic library (`.dll` on Windows, `.so` on Unix-like systems, and `.dylib` on macOS) and MUST export a public initialization function named `prefix_extension_init`. The interpreter MUST call that function with the extension context defined in `prefix_extension.h`, which provides the API version constant together with registration callbacks for operators, custom types, event handlers, periodic hooks, and optional REPL replacement.
 
@@ -686,9 +686,11 @@
 
 - `register_repl_handler(repl_fn)` to replace or augment the default REPL implementation.
 
-A `.prex` pointer file MUST be treated as a text file containing one extension path per line. Blank lines MUST be ignored, and lines beginning with `!` MUST be treated as comments. Relative paths in a pointer file MUST be resolved relative to the pointer file's directory, with the current working directory and the interpreter's `ext/std/` and `ext/usr/` directories available as fallbacks when necessary. When both bundled and user extension directories are searched, `ext/std/` MUST be consulted before `ext/usr/`.
+The interpreter MUST NOT load `.prex` pointer files.
 
-If a `.prex` file is supplied as an argument, the interpreter MUST load all referenced extensions. If no explicit extension arguments are supplied, the interpreter MUST also search for an automatically-discovered pointer file named `.prex` in the current working directory, and when running a source file it MUST also search the program's directory and the companion `<program>.prex` file beside the source file.
+Runtime extension loading from Prefix source MUST use `EXTEND(EXTENSION: ext)`, defined in [9.1.8](#918-function-and-module-operators). The `ext` specifier MUST exclude the platform filename suffix (`.dll`, `.so`, `.dylib`) and MAY use package semantics with `..`. When `ext` names a package, the loader MUST attempt `ext..init`.
+
+`EXTEND` MUST resolve extension libraries using the same extension search roots used by compiled-library loading: the calling module directory when available, then current working directory, then interpreter `ext/std`, `ext/usr`, `lib/std`, and `lib/usr` roots with bundled roots consulted before user roots.
 
 ---
 
@@ -726,6 +728,8 @@
 
 `MODULE` is a pseudo-type indicating that the argument MUST be a plain unquoted module identifier or a package-qualified module name using the language's `..` separator. A slash-separated signature such as `ADD/SUB/MUL` denotes a family of distinct operators that share the same argument rules and differ only in the named operation.
 
+`EXTENSION` is a pseudo-type indicating that the argument MUST be a plain unquoted extension specifier used by `EXTEND`, excluding the platform filename suffix and optionally using package-style `..` separators.
+
 `INT` and `FLT` are not interoperable. Unless an operator explicitly permits or requires type mixing, all numeric operands MUST share the same numeric type; supplying mismatched types MUST raise a runtime error. The numeric base of an operation's result MUST be the highest base present among its numeric operands.
 
 Built-in operator names MUST be matched case-sensitively and MUST be written in their canonical form. A user-defined function MUST NOT share a name with any built-in operator; such a conflict MUST raise a runtime error. Extensions MAY register additional operators, which are dispatched through the same call syntax and MAY be qualified with a dotted extension-name prefix, but whose names MUST NOT conflict with those of built-in operators.
@@ -880,17 +884,21 @@
 
 - `INT: MAIN()` = MUST return `1` when the call site is in the primary program source and `0` when the call site is executing from imported module code. The result MUST depend on the source location of the call expression rather than on the dynamic caller stack.
 
-- `IMPORT(MODULE: name)` or `IMPORT(MODULE: name, SYMBOL: alias)` = MUST load the named module, execute it in its own top-level environment on first import, cache that environment, and expose its bindings under the module name or the supplied alias. The implementation MUST search the referring source directory first, then bundled library locations as described in [8.2](#82-extensions-and-pointer-files), [10](#10-standard-library), and the language's module-search rules. Re-importing an already loaded module MUST reuse the cached module namespace rather than re-executing the module.
+- `INT: EXTEND(EXTENSION: ext)` = MUST load the compiled extension designated by `ext`. The specifier `ext` MUST exclude the platform filename suffix and MAY use package-style `..` separators. If `ext` resolves to a package, the loader MUST attempt `ext..init`. Relative extension names MUST resolve using the calling module's source directory when available, then the current working directory, then the configured extension roots `ext/std`, `ext/usr`, `lib/std`, and `lib/usr` (with bundled roots searched before user roots). Repeating an `EXTEND` request for an already-loaded extension exposure MUST be idempotent.
+
+  Operators registered with module-qualified flags (for example `PREFIX_EXTENSION_ASMODULE`) MUST be exposed only under the extending module's namespace. Importing that module MUST expose the extension namespace qualifier under the importing module's qualified name. Extension side effects outside operator registration (for example process-global hooks or host-side state) remain global.
+
+- `IMPORT(MODULE: name)` or `IMPORT(MODULE: name, SYMBOL: alias)` = MUST load the named module, execute it in its own top-level environment on first import, cache that environment, and expose its bindings under the module name or the supplied alias. The implementation MUST search the referring source directory first, then bundled library locations as described in [8.2](#82-extensions-and-extend), [10](#10-standard-library), and the language's module-search rules. Re-importing an already loaded module MUST reuse the cached module namespace rather than re-executing the module.
 
   Prefix package namespaces MUST use `..` as the package separator. The canonical form is `package..subpackage..module`. When `IMPORT(pkg)` is used and a package directory named `pkg` exists, the interpreter MUST prefer package resolution and attempt to load `pkg/init.pre`. If that package directory exists but contains no `init.pre`, the import MUST raise a runtime error. When `IMPORT(pkg..mod)` is used, the interpreter MUST resolve to `pkg/mod.pre`. If both a package directory and a same-named module file exist in the same search location, the package MUST take precedence.
 
   When the referring source was itself loaded from a file, the search MUST begin in that source file's directory. When the referring source is executing via `-source`, the primary search directory MUST be the current working directory. After local search, the interpreter MUST consult `lib/std/` immediately before `lib/usr/`.
 
   On first import, the module source MUST execute in its own isolated top-level environment. Unqualified identifiers during that execution MUST resolve within the module's own namespace. After execution completes, that namespace MUST be cached and reused by subsequent imports in the same interpreter process. Multiple aliases for the same module MUST provide distinct qualified views into the same cached module instance.
 
-  When a module is imported, the interpreter MUST also attempt to load any associated runtime extensions. It MUST first look for a companion pointer file named `<module>.prex` beside the resolved module source. If no such pointer file is present, or as an additional fallback, it MUST also check the configured extension search locations for a same-named extension module. Any extensions loaded this way MUST become available before control returns from the import.
+  Module import MUST NOT implicitly load companion extension pointer files. Runtime extensions for module code MUST be loaded explicitly via `EXTEND` inside the module.
 
-- `IMPORT_PATH(STR: path)` or `IMPORT_PATH(STR: path, SYMBOL: alias)` = MUST load a module from an explicit filesystem path and expose it under `alias` or, if omitted, under a basename-derived module name. The argument MUST at minimum accept an absolute path to a `.pre` source file. The module's basename, excluding the `.pre` suffix, MUST be used as the default qualified module name when no alias is supplied. The loaded module MUST otherwise obey the same isolation, caching, and exposure rules as `IMPORT`, including companion extension loading from a sibling `<module>.prex` pointer file when present and same-named extension-module lookup in the configured extension search locations.
+- `IMPORT_PATH(STR: path)` or `IMPORT_PATH(STR: path, SYMBOL: alias)` = MUST load a module from an explicit filesystem path and expose it under `alias` or, if omitted, under a basename-derived module name. The argument MUST at minimum accept an absolute path to a `.pre` source file. The module's basename, excluding the `.pre` suffix, MUST be used as the default qualified module name when no alias is supplied. The loaded module MUST otherwise obey the same isolation, caching, and exposure rules as `IMPORT`. Runtime extensions for that module MUST be loaded explicitly via `EXTEND`.
 
 - `INT: EXPORT(SYMBOL: symbol, MODULE: module)` = MUST copy the caller's current binding for `symbol` into the namespace of the already imported module designated by `module`, making the exported binding available through that module's qualified namespace. `EXPORT` MUST return `0` on success and MUST raise a runtime error if `module` is not currently imported.
 

lib/std/gui/init.pre

@@ -1,5 +1,7 @@
 ! `image`-interoperable GUI operations for Prefix
 
+EXTEND(EXTENSION: gui)
+
 FUNC INT: SCREEN_WIDTH(){
     RETURN(gui.SCREEN()[0d1])
 }

lib/std/gui/init.prex

@@ -4,6 +4,8 @@
 ! The returned tensor layout is [column][row][channel] (width, height, channel)
 ! in user code. Channels are ordered r, g, b, a and values are 0..255.
 
+EXTEND(EXTENSION: image)
+
 IMPORT(path)
 
 FUNC TNS: LOAD(STR: img_path){

lib/std/image/init.pre

@@ -330,6 +330,42 @@ static char* canonicalize_existing_path(const char* path) {
     return strdup(path);
 }
 
+static char* module_source_dir_dup(Env* env) {
+    if (!env) return NULL;
+    EnvEntry* src_entry = env_get_entry(env, "__MODULE_SOURCE__");
+    if (!src_entry || !src_entry->initialized || src_entry->value.type != VAL_STR || !src_entry->value.as.s) {
+        return NULL;
+    }
+
+    const char* src = src_entry->value.as.s;
+    if (src[0] == '\0' || strcmp(src, "<string>") == 0 || strcmp(src, "<repl>") == 0) {
+        return NULL;
+    }
+
+    char* dir = strdup(src);
+    if (!dir) return NULL;
+
+    char* last_sep = NULL;
+    for (char* p = dir; *p; p++) {
+        if (*p == '/' || *p == '\\') last_sep = p;
+    }
+    if (last_sep) {
+        *last_sep = '\0';
+    } else {
+        strcpy(dir, ".");
+    }
+    return dir;
+}
+
+static const char* module_scope_name(Env* env) {
+    if (!env) return NULL;
+    EnvEntry* scope_entry = env_get_entry(env, "__MODULE_SCOPE__");
+    if (!scope_entry || !scope_entry->initialized || scope_entry->value.type != VAL_STR || !scope_entry->value.as.s) {
+        return NULL;
+    }
+    return scope_entry->value.as.s[0] != '\0' ? scope_entry->value.as.s : NULL;
+}
+
     // Global argv storage (set by main via builtins_set_argv)
     static int g_argc = 0;
     static char** g_argv = NULL;
@@ -4847,6 +4883,11 @@ static Value builtin_import_path(Interpreter* interp, Value* args, int argc, Exp
         (void)module_register_alias(interp, alias, mod_env);
     }
 
+    EnvEntry* scope_entry = env_get_entry(mod_env, "__MODULE_SCOPE__");
+    if (!scope_entry || !scope_entry->initialized || scope_entry->value.type != VAL_STR) {
+        env_assign(mod_env, "__MODULE_SCOPE__", value_str(alias), TYPE_STR, true);
+    }
+
     // If not already loaded, execute module source once.
     EnvEntry* marker = env_get_entry(mod_env, "__MODULE_LOADED__");
     if ((!marker || !marker->initialized) && found_path) {
@@ -6817,6 +6858,57 @@ static Value builtin_exit(Interpreter* interp, Value* args, int argc, Expr** arg
     (void)code; // exit does not return
 }
 
+static Value builtin_extend(Interpreter* interp, Value* args, int argc, Expr** arg_nodes, Env* env, int line, int col) {
+    if (argc < 1 || !arg_nodes || !arg_nodes[0]) {
+        RUNTIME_ERROR(interp, "EXTEND expects EXTENSION: name", line, col);
+    }
+
+    const char* spec = NULL;
+    Expr* spec_node = arg_nodes[0];
+
+    if (spec_node->type == EXPR_TYPED_IDENT) {
+        spec = spec_node->as.typed_ident.name;
+    } else if (spec_node->type == EXPR_IDENT) {
+        spec = spec_node->as.ident;
+    } else if (args && args[0].type == VAL_STR) {
+        spec = args[0].as.s;
+    }
+
+    if (!spec || spec[0] == '\0') {
+        RUNTIME_ERROR(interp, "EXTEND expects a non-empty extension specifier", line, col);
+    }
+
+    char* base_dir = module_source_dir_dup(env);
+    const char* scope_name = module_scope_name(env);
+
+    char* loaded_name = NULL;
+    char* ext_err = NULL;
+    int rc = extensions_load_named(spec, base_dir, scope_name, &loaded_name, &ext_err);
+    free(base_dir);
+
+    if (rc != 0) {
+        if (ext_err) {
+            interp->error = strdup(ext_err);
+            free(ext_err);
+        } else {
+            interp->error = strdup("EXTEND failed to load extension");
+        }
+        interp->error_line = line;
+        interp->error_col = col;
+        free(loaded_name);
+        return value_null();
+    }
+
+    // Expose the extension namespace symbol in the current module environment.
+    if (loaded_name && loaded_name[0] != '\0') {
+        (void)env_assign(env, loaded_name, value_str(""), TYPE_STR, true);
+    }
+
+    free(loaded_name);
+    free(ext_err);
+    return value_int(0);
+}
+
 // Stubs for operations requiring TNS/MAP/THD
 static Value builtin_import(Interpreter* interp, Value* args, int argc, Expr** arg_nodes, Env* env, int line, int col) {
     (void)args; (void)argc;
@@ -6974,40 +7066,6 @@ static Value builtin_import(Interpreter* interp, Value* args, int argc, Expr** a
         }
     }
 
-    /* Attempt to load a companion .prex pointer file next to the resolved
-       module file so that any extension libraries listed there are available
-    during module execution (e.g. lib/std/image/init.prex -> win32.dll). */
-    if (found_path) {
-        char noext[2048];
-        strncpy(noext, found_path, sizeof(noext)-1);
-        noext[sizeof(noext)-1] = '\0';
-        char* dot = strrchr(noext, '.');
-        if (dot) *dot = '\0';
-        size_t need = strlen(noext) + strlen(".prex") + 1;
-        char* companion_prex = malloc(need);
-        if (companion_prex) {
-            snprintf(companion_prex, need, "%s.prex", noext);
-            char* ext_err = NULL;
-            int loaded_any = 0;
-            if (extensions_load_prex_if_exists(companion_prex, &loaded_any, &ext_err) != 0) {
-                if (ext_err) {
-                    interp->error = strdup(ext_err);
-                    free(ext_err);
-                } else {
-                    interp->error = strdup("Failed to load companion .prex");
-                }
-                interp->error_line = line;
-                interp->error_col = col;
-                free(companion_prex);
-                free(found_path);
-                free(canonical_path);
-                return value_null();
-            }
-            free(ext_err);
-            free(companion_prex);
-        }
-    }
-
     Env* mod_env = module_env_lookup(interp, cache_key);
     if (!mod_env) mod_env = module_env_lookup(interp, modname);
     if (!mod_env) {
@@ -7031,6 +7089,11 @@ static Value builtin_import(Interpreter* interp, Value* args, int argc, Expr** a
         (void)module_register_alias(interp, found_path, mod_env);
     }
 
+    EnvEntry* scope_entry = env_get_entry(mod_env, "__MODULE_SCOPE__");
+    if (!scope_entry || !scope_entry->initialized || scope_entry->value.type != VAL_STR) {
+        env_assign(mod_env, "__MODULE_SCOPE__", value_str(modname), TYPE_STR, true);
+    }
+
     EnvEntry* marker = env_get_entry(mod_env, "__MODULE_LOADED__");
     if ((!marker || !marker->initialized) && found_path) {
         FILE* f = fopen(found_path, "rb");
@@ -7863,6 +7926,7 @@ static BuiltinFunction builtins_table[] = {
     {"MAIN", 0, 0, builtin_main},
     {"OS", 0, 0, builtin_os},
     {"EXIT", 0, 1, builtin_exit},
+    {"EXTEND", 1, 1, builtin_extend},
     {"IMPORT", 1, 2, builtin_import},
     {"IMPORT_PATH", 1, 2, builtin_import_path},
     {"EXPORT", 2, 2, builtin_export},