janky-jit 1.0.0__tar.gz

janky_jit-1.0.0/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: janky-jit
+Version: 1.0.0
+Summary: Hyper-optimized, multi-language polyglot JIT framework for Python.
+Author: Adam
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: systems
+Provides-Extra: zig
+Provides-Extra: nim
+Provides-Extra: all
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+# 🏗️ Janky
+
+> It is not a bug, it is architectural dominance.
+
+Janky is a hyper-optimized, native compilation polyglot JIT framework for Python. It allows you to embed raw **Assembly (64-bit and retro 32-bit), C++, Rust, Zig (Jig), Pure C, Nim, Raw Machine Code Hex Strings (Jinary), and Brainfuck** source strings directly within your Python scripts, compilation-cached via OpenSSL SHA-256 fingerprinting, and executed at bare-metal speeds with zero abstraction overhead.
+
+The core C compilation engines are secured behind an absolute systems-level Linux virtual filesystem lock (`chattr +i`). Janky bypasses Python's runtime limitations by loading compiled `.so` binaries directly into active memory using `dlopen` or mapping execution blocks natively into memory via `mprotect`.
+
+---
+
+## 🚀 The Native Core Lineup
+
+| Extension | Language | Backend Toolchain | Best Used For | Boilerplate Magic |
+| --- | --- | --- | --- | --- |
+| `jasm` | x86-64 Assembly | `nasm` | Raw register control, vector ops | Pure `sysv` ABI assembly |
+| `jasm86` | 32-bit x86 Assembly | `nasm` | Stack-based legacy shellcode hacking | 32-bit memory sandbox execution |
+| `jcpp` | C++ | `g++` | Heavy OOP, Matrix math, game physics | Requires `extern "C"` linkage |
+| `just` | Rust | `rustc` | Memory-safe pipelines, hyper-threading | Requires `#[no_mangle] pub extern "C"` |
+| `jig` | Zig | `zig` | Ultra-modern, low-overhead algorithms | Requires `export fn` notation |
+| `jc` | Pure C | `gcc` / `clang` | Fastest cold compilation, retro tasks | Native C symbol preservation |
+| `jnim` | Nim | `nim` | Python-like syntax at bare-metal speeds | Requires `{.exportc, cdecl.}` |
+| `jinary` | Raw Binary Hex | `mprotect` Runtime | Direct execution of raw opcode arrays | Requires raw x86-64 executable hex |
+| `jbrainfuck` | Brainfuck | Native JIT Gen | Melting-fast esoteric logic execution | Emits optimized x86-64 opcodes directly |
+
+---
+
+## 💾 Installation & Setup
+
+### 1. Install System Dependencies
+
+Ensure your machine is weaponized with the required system compilers:
+
+```bash
+# Core Build Tools & OpenSSL development headers
+sudo apt update
+sudo apt install build-essential nasm libssl-dev
+
+# Modern Compiler Ecosystem
+sudo apt install zig nim
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+```
+
+### 2. Compile the Janky Extension Matrix
+
+Navigate to your project directory, activate your virtual environment, and fire the build:
+
+```bash
+# Clean out any old stale build artifacts
+rm -rf build/
+
+# Compile and register all 9 native extension wrappers
+pip install .
+
+```
+
+### 3. Seal the Fortress 🔒
+
+Protect your foundational compiler engines from accidental edits or late-night programming accidents by locking them directly into the Linux Kernel space:
+
+```bash
+sudo chattr -R +i janky/compiler
+
+```
+
+*Note: If you ever need to upgrade the core engines, lift the spell with `sudo chattr -R -i janky/compiler`.*
+
+---
+
+## 🎸 Quick Start Tour (Polyglot Blitz)
+
+You can now import and utilize **any** low-level native engine from anywhere on your machine as long as your virtual environment is active!
+
+```python
+import time
+from janky.compiler import jasm, just, jig, jc, jnim, jinary, jbrainfuck
+
+# ==============================================================================
+# 1. JINARY (Raw Executable Machine Code Opcodes)
+# ==============================================================================
+# Raw hex bytes for: mov rax, rdi (48 89 f8); add rax, rsi (48 01 f0); ret (c3)
+hex_code = "4889f84801f0c3"
+jinary_engine = jinary.compile(hex_code, "raw_exec")
+print(f"Jinary Machine Code Add: {jinary_engine(20, 22)}")  # 42
+
+
+# ==============================================================================
+# 2. BRAINFUCK (Natively Optimized JIT Compiler)
+# ==============================================================================
+bf_code = "++++++++++[>+++++++>++++++++++<<-]>++.>+.[-]"
+jbf_engine = jbrainfuck.compile(bf_code, "bf_run")
+tape = bytearray(30000)
+print("Executing JIT Brainfuck:")
+jbf_engine(tape)  # Prints 'Hi' directly via optimized native write syscalls
+
+
+# ==============================================================================
+# 3. PURE C (Fastest Cold Compile)
+# ==============================================================================
+c_code = """
+#include <stdint.h>
+uint64_t c_factorial(uint64_t n) {
+    return (n <= 1) ? 1 : n * c_factorial(n - 1);
+}
+"""
+jc_engine = jc.compile(c_code, "c_factorial")
+print(f"Pure C Factorial(5): {jc_engine(5)}")  # 120
+
+
+# ==============================================================================
+# 4. RUST (Memory Safe & Optimizing)
+# ==============================================================================
+rust_code = """
+#[no_mangle]
+pub extern "C" fn rust_cube(x: u64) -> u64 {
+    x * x * x
+}
+"""
+rust_engine = just.compile(rust_code, "rust_cube")
+print(f"Rust Cube(3): {rust_engine(3)}")  # 27
+
+
+# ==============================================================================
+# 5. ZIG / JIG (Modern & Transparent)
+# ==============================================================================
+zig_code = """
+export fn zig_xor(a: u64, b: u64) u64 {
+    return a ^ b;
+}
+"""
+jig_engine = jig.compile(zig_code, "zig_xor")
+print(f"Zig Bitwise XOR: {jig_engine(1024, 1)}")  # 1025
+
+
+# ==============================================================================
+# 6. NIM (Pythonic Syntax, C Execution Speed)
+# ==============================================================================
+nim_code = """
+proc nim_fib(n: int64): int64 {.exportc, cdecl.} =
+  if n <= 1: return n
+  else: return nim_fib(n - 1) + nim_fib(n - 2)
+"""
+jnim_engine = jnim.compile(nim_code, "nim_fib")
+print(f"Nim Fibonacci(10): {jnim_engine(10)}")  # 55
+
+
+# ==============================================================================
+# 7. X86-64 ASSEMBLY (Ultimate Control)
+# ==============================================================================
+asm_code = """
+global asm_add
+section .text
+asm_add:
+    mov rax, rdi    ; rdi is first argument (a)
+    add rax, rsi    ; rsi is second argument (b)
+    ret             ; Return value stored in rax
+"""
+jasm_engine = jasm.compile(asm_code, "asm_add")
+print(f"Raw Assembly Add: {jasm_engine(40, 2)}")  # 42
+
+```
+
+---
+
+## 🛠️ Performance & Architecture
+
+Every time you execute a `.compile()` string across any language module:
+
+1. **Fingerprinting:** Janky hashes the source code token string using OpenSSL SHA-256.
+2. **Hit Detection:** If the hash exists inside the `.janky_cache/` directory, the compiler execution is completely skipped, instantly performing a high-speed `dlopen` read on the pre-compiled `.so` block or reusing memory allocated regions.
+3. **Arguments Passthrough:** Up to 6 standard integer variables or direct **raw memory block pointer addresses** (via Python's buffer protocol) can be funneled directly into function parameters with **zero serialization penalty**.
+
+## 🛑 Project Boundaries / Guardrails
+
+* **Do not modify `janky/compiler/` contents.** The kernel will throw a hard `Operation not permitted`.
+* **Argument Constraint:** Maximum of 6 arguments map natively to system registers under the current C calling architecture wrapper.
+
+---
+
+## 📜 License
+
+Unlicensed. Pure hacking freedom. Go break some memory limits.

janky_jit-1.0.0/README.md

@@ -0,0 +1,182 @@
+# 🏗️ Janky
+
+> It is not a bug, it is architectural dominance.
+
+Janky is a hyper-optimized, native compilation polyglot JIT framework for Python. It allows you to embed raw **Assembly (64-bit and retro 32-bit), C++, Rust, Zig (Jig), Pure C, Nim, Raw Machine Code Hex Strings (Jinary), and Brainfuck** source strings directly within your Python scripts, compilation-cached via OpenSSL SHA-256 fingerprinting, and executed at bare-metal speeds with zero abstraction overhead.
+
+The core C compilation engines are secured behind an absolute systems-level Linux virtual filesystem lock (`chattr +i`). Janky bypasses Python's runtime limitations by loading compiled `.so` binaries directly into active memory using `dlopen` or mapping execution blocks natively into memory via `mprotect`.
+
+---
+
+## 🚀 The Native Core Lineup
+
+| Extension | Language | Backend Toolchain | Best Used For | Boilerplate Magic |
+| --- | --- | --- | --- | --- |
+| `jasm` | x86-64 Assembly | `nasm` | Raw register control, vector ops | Pure `sysv` ABI assembly |
+| `jasm86` | 32-bit x86 Assembly | `nasm` | Stack-based legacy shellcode hacking | 32-bit memory sandbox execution |
+| `jcpp` | C++ | `g++` | Heavy OOP, Matrix math, game physics | Requires `extern "C"` linkage |
+| `just` | Rust | `rustc` | Memory-safe pipelines, hyper-threading | Requires `#[no_mangle] pub extern "C"` |
+| `jig` | Zig | `zig` | Ultra-modern, low-overhead algorithms | Requires `export fn` notation |
+| `jc` | Pure C | `gcc` / `clang` | Fastest cold compilation, retro tasks | Native C symbol preservation |
+| `jnim` | Nim | `nim` | Python-like syntax at bare-metal speeds | Requires `{.exportc, cdecl.}` |
+| `jinary` | Raw Binary Hex | `mprotect` Runtime | Direct execution of raw opcode arrays | Requires raw x86-64 executable hex |
+| `jbrainfuck` | Brainfuck | Native JIT Gen | Melting-fast esoteric logic execution | Emits optimized x86-64 opcodes directly |
+
+---
+
+## 💾 Installation & Setup
+
+### 1. Install System Dependencies
+
+Ensure your machine is weaponized with the required system compilers:
+
+```bash
+# Core Build Tools & OpenSSL development headers
+sudo apt update
+sudo apt install build-essential nasm libssl-dev
+
+# Modern Compiler Ecosystem
+sudo apt install zig nim
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+```
+
+### 2. Compile the Janky Extension Matrix
+
+Navigate to your project directory, activate your virtual environment, and fire the build:
+
+```bash
+# Clean out any old stale build artifacts
+rm -rf build/
+
+# Compile and register all 9 native extension wrappers
+pip install .
+
+```
+
+### 3. Seal the Fortress 🔒
+
+Protect your foundational compiler engines from accidental edits or late-night programming accidents by locking them directly into the Linux Kernel space:
+
+```bash
+sudo chattr -R +i janky/compiler
+
+```
+
+*Note: If you ever need to upgrade the core engines, lift the spell with `sudo chattr -R -i janky/compiler`.*
+
+---
+
+## 🎸 Quick Start Tour (Polyglot Blitz)
+
+You can now import and utilize **any** low-level native engine from anywhere on your machine as long as your virtual environment is active!
+
+```python
+import time
+from janky.compiler import jasm, just, jig, jc, jnim, jinary, jbrainfuck
+
+# ==============================================================================
+# 1. JINARY (Raw Executable Machine Code Opcodes)
+# ==============================================================================
+# Raw hex bytes for: mov rax, rdi (48 89 f8); add rax, rsi (48 01 f0); ret (c3)
+hex_code = "4889f84801f0c3"
+jinary_engine = jinary.compile(hex_code, "raw_exec")
+print(f"Jinary Machine Code Add: {jinary_engine(20, 22)}")  # 42
+
+
+# ==============================================================================
+# 2. BRAINFUCK (Natively Optimized JIT Compiler)
+# ==============================================================================
+bf_code = "++++++++++[>+++++++>++++++++++<<-]>++.>+.[-]"
+jbf_engine = jbrainfuck.compile(bf_code, "bf_run")
+tape = bytearray(30000)
+print("Executing JIT Brainfuck:")
+jbf_engine(tape)  # Prints 'Hi' directly via optimized native write syscalls
+
+
+# ==============================================================================
+# 3. PURE C (Fastest Cold Compile)
+# ==============================================================================
+c_code = """
+#include <stdint.h>
+uint64_t c_factorial(uint64_t n) {
+    return (n <= 1) ? 1 : n * c_factorial(n - 1);
+}
+"""
+jc_engine = jc.compile(c_code, "c_factorial")
+print(f"Pure C Factorial(5): {jc_engine(5)}")  # 120
+
+
+# ==============================================================================
+# 4. RUST (Memory Safe & Optimizing)
+# ==============================================================================
+rust_code = """
+#[no_mangle]
+pub extern "C" fn rust_cube(x: u64) -> u64 {
+    x * x * x
+}
+"""
+rust_engine = just.compile(rust_code, "rust_cube")
+print(f"Rust Cube(3): {rust_engine(3)}")  # 27
+
+
+# ==============================================================================
+# 5. ZIG / JIG (Modern & Transparent)
+# ==============================================================================
+zig_code = """
+export fn zig_xor(a: u64, b: u64) u64 {
+    return a ^ b;
+}
+"""
+jig_engine = jig.compile(zig_code, "zig_xor")
+print(f"Zig Bitwise XOR: {jig_engine(1024, 1)}")  # 1025
+
+
+# ==============================================================================
+# 6. NIM (Pythonic Syntax, C Execution Speed)
+# ==============================================================================
+nim_code = """
+proc nim_fib(n: int64): int64 {.exportc, cdecl.} =
+  if n <= 1: return n
+  else: return nim_fib(n - 1) + nim_fib(n - 2)
+"""
+jnim_engine = jnim.compile(nim_code, "nim_fib")
+print(f"Nim Fibonacci(10): {jnim_engine(10)}")  # 55
+
+
+# ==============================================================================
+# 7. X86-64 ASSEMBLY (Ultimate Control)
+# ==============================================================================
+asm_code = """
+global asm_add
+section .text
+asm_add:
+    mov rax, rdi    ; rdi is first argument (a)
+    add rax, rsi    ; rsi is second argument (b)
+    ret             ; Return value stored in rax
+"""
+jasm_engine = jasm.compile(asm_code, "asm_add")
+print(f"Raw Assembly Add: {jasm_engine(40, 2)}")  # 42
+
+```
+
+---
+
+## 🛠️ Performance & Architecture
+
+Every time you execute a `.compile()` string across any language module:
+
+1. **Fingerprinting:** Janky hashes the source code token string using OpenSSL SHA-256.
+2. **Hit Detection:** If the hash exists inside the `.janky_cache/` directory, the compiler execution is completely skipped, instantly performing a high-speed `dlopen` read on the pre-compiled `.so` block or reusing memory allocated regions.
+3. **Arguments Passthrough:** Up to 6 standard integer variables or direct **raw memory block pointer addresses** (via Python's buffer protocol) can be funneled directly into function parameters with **zero serialization penalty**.
+
+## 🛑 Project Boundaries / Guardrails
+
+* **Do not modify `janky/compiler/` contents.** The kernel will throw a hard `Operation not permitted`.
+* **Argument Constraint:** Maximum of 6 arguments map natively to system registers under the current C calling architecture wrapper.
+
+---
+
+## 📜 License
+
+Unlicensed. Pure hacking freedom. Go break some memory limits.

janky_jit-1.0.0/janky/__init__.py

@@ -0,0 +1 @@
+from . import compiler

janky_jit-1.0.0/janky/compiler/__init__.py

@@ -0,0 +1,10 @@
+# janky/compiler/__init__.py
+from .. import jasm
+from .. import jasm86
+from .. import jcpp
+from .. import just
+from .. import jig
+from .. import jc
+from .. import jnim
+from .. import jinary
+from .. import jbrainfuck # New!

janky_jit-1.0.0/janky/compiler/jasm.c

@@ -0,0 +1,218 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <string.h>
+#include <sys/mman.h> 
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdint.h>
+
+// Helper to read files safely
+unsigned char *read_file(const char *filename, size_t *out_size) {
+    FILE *f = fopen(filename, "rb");
+    if (!f) return NULL;
+    
+    fseek(f, 0, SEEK_END);
+    long size = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    
+    if (size <= 0) {
+        fclose(f);
+        return NULL;
+    }
+    
+    unsigned char *data = (unsigned char *)malloc(size);
+    if (!data) {
+        fclose(f);
+        return NULL;
+    }
+    
+    size_t read_bytes = fread(data, 1, size, f);
+    fclose(f);
+    
+    *out_size = read_bytes;
+    return data;
+}
+
+// Helper to read NASM build errors and raise them inside Python
+static void raise_nasm_error(const char *err_file) {
+    size_t err_size = 0;
+    unsigned char *err_data = read_file(err_file, &err_size);
+    if (err_data && err_size > 0) {
+        // Null terminate the error log safely
+        char *err_msg = malloc(err_size + 1);
+        if (err_msg) {
+            memcpy(err_msg, err_data, err_size);
+            err_msg[err_size] = '\0';
+            PyErr_Format(PyExc_SyntaxError, "NASM compilation failed:\n%s", err_msg);
+            free(err_msg);
+        } else {
+            PyErr_SetString(PyExc_SyntaxError, "NASM compilation failed (out of memory reading logs).");
+        }
+        free(err_data);
+    } else {
+        PyErr_SetString(PyExc_SyntaxError, "NASM compilation failed with unknown syntax errors.");
+    }
+}
+
+typedef struct {
+    PyObject_HEAD
+    unsigned char *code;
+    size_t code_size;
+} AssemblyFunction;
+
+static void AssemblyFunction_dealloc(AssemblyFunction *self) {
+    if (self->code) {
+        munmap(self->code, self->code_size);
+    }
+    Py_TYPE(self)->tp_free((PyObject *)self);
+}
+
+static PyObject *AssemblyFunction_call(AssemblyFunction *self, PyObject *args, PyObject *kwargs) {
+    Py_ssize_t nargs = PyTuple_Size(args);
+    if (nargs > 6) {
+        PyErr_SetString(PyExc_ValueError, "System V AMD64 ABI supports a max of 6 register arguments");
+        return NULL;
+    }
+
+    uint64_t call_args[6] = {0};
+
+    for (Py_ssize_t i = 0; i < nargs; i++) {
+        PyObject *item = PyTuple_GetItem(args, i);
+        
+        // If it's an integer, pass it raw
+        if (PyLong_Check(item)) {
+            call_args[i] = (uint64_t)PyLong_AsUnsignedLongLong(item);
+            if (PyErr_Occurred()) return NULL;
+        } 
+        // If it supports the Buffer Protocol (bytes, bytearray, memoryview), pass its raw memory pointer!
+        else if (PyObject_CheckBuffer(item)) {
+            Py_buffer view;
+            if (PyObject_GetBuffer(item, &view, PyBUF_SIMPLE) == 0) {
+                call_args[i] = (uint64_t)view.buf;
+                PyBuffer_Release(&view); // Release the view handle, but the pointer address remains valid during call
+            } else {
+                PyErr_SetString(PyExc_TypeError, "Failed to extract buffer pointer");
+                return NULL;
+            }
+        } else {
+            PyErr_SetString(PyExc_TypeError, "Arguments must be integers or buffer-like objects (bytes/bytearray).");
+            return NULL;
+        }
+    }
+    
+    // Pure execution mapping directly to standard System V ABI calling convention:
+    // rdi, rsi, rdx, rcx, r8, r9
+    uint64_t (*func)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t) = 
+        (uint64_t (*)(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t))(self->code);
+        
+    // Execute raw hardware thread!
+    uint64_t result = func(call_args[0], call_args[1], call_args[2], 
+                           call_args[3], call_args[4], call_args[5]);
+                       
+    return PyLong_FromUnsignedLongLong(result);
+}
+
+static PyTypeObject AssemblyFunctionType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_name = "janky.AssemblyFunction",
+    .tp_basicsize = sizeof(AssemblyFunction),
+    .tp_dealloc = (destructor)AssemblyFunction_dealloc,
+    .tp_call = (ternaryfunc)AssemblyFunction_call,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
+    .tp_doc = "Callable raw assembly function",
+};
+
+static PyObject *compile_asm(PyObject *self, PyObject *args) {
+    const char *asm_code;
+    if (!PyArg_ParseTuple(args, "s", &asm_code)) return NULL;
+    
+    const char *asm_file = "/tmp/janky_temp.asm";
+    const char *obj_file = "/tmp/janky_temp.o";
+    const char *err_file = "/tmp/janky_error.txt";
+    
+    FILE *f = fopen(asm_file, "w");
+    if (!f) { PyErr_SetString(PyExc_RuntimeError, "Cannot write temporary assembly file"); return NULL; }
+    
+    // We strictly specify BITS 64, nothing else. The user writes clean, pure, unrestricted assembly.
+    fprintf(f, "BITS 64\n");
+    fprintf(f, "%s\n", asm_code);
+    fclose(f);
+    
+    char cmd[1024];
+    snprintf(cmd, sizeof(cmd), "nasm -f bin -o %s %s 2>%s", obj_file, asm_file, err_file);
+    if (system(cmd) != 0) {
+        raise_nasm_error(err_file);
+        unlink(asm_file);
+        unlink(obj_file);
+        unlink(err_file);
+        return NULL;
+    }
+    
+    size_t code_size = 0;
+    unsigned char *code_bytes = read_file(obj_file, &code_size);
+    
+    unlink(asm_file);
+    unlink(obj_file);
+    unlink(err_file);
+    
+    if (!code_bytes || code_size == 0) {
+        PyErr_SetString(PyExc_RuntimeError, "Compiled binary was empty or corrupt.");
+        return NULL;
+    }
+    
+    // Allocate page-aligned memory
+    unsigned char *exec_mem = mmap(NULL, code_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (exec_mem == MAP_FAILED) {
+        free(code_bytes);
+        PyErr_SetString(PyExc_RuntimeError, "mmap mapping execution space failed");
+        return NULL;
+    }
+    
+    memcpy(exec_mem, code_bytes, code_size);
+    free(code_bytes);
+
+    // Swap permissions to strictly Read + Execute (W^X security adherence)
+    if (mprotect(exec_mem, code_size, PROT_READ | PROT_EXEC) == -1) {
+        munmap(exec_mem, code_size);
+        PyErr_SetString(PyExc_RuntimeError, "mprotect memory lockdown failed");
+        return NULL;
+    }
+    
+    AssemblyFunction *func_obj = PyObject_New(AssemblyFunction, &AssemblyFunctionType);
+    if (!func_obj) {
+        munmap(exec_mem, code_size);
+        return NULL;
+    }
+    func_obj->code = exec_mem;
+    func_obj->code_size = code_size;
+    return (PyObject *)func_obj;
+}
+
+static PyMethodDef JasmMethods[] = {
+    {"compile", compile_asm, METH_VARARGS, "Compile raw x86-64 assembly using NASM"},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef jasm_module = {
+    PyModuleDef_HEAD_INIT,
+    "jasm",
+    "Full raw x86-64 assembly injection engine for Python",
+    -1,
+    JasmMethods
+};
+
+PyMODINIT_FUNC PyInit_jasm(void) {
+    PyObject *m = PyModule_Create(&jasm_module);
+    if (!m) return NULL;
+    if (PyType_Ready(&AssemblyFunctionType) < 0) return NULL;
+    
+    // Modernized Python 3.10+ safe reference addition
+    Py_INCREF(&AssemblyFunctionType);
+    if (PyModule_AddObject(m, "AssemblyFunction", (PyObject *)&AssemblyFunctionType) < 0) {
+        Py_DECREF(&AssemblyFunctionType);
+        Py_DECREF(m);
+        return NULL;
+    }
+    return m;
+}