zexus 1.8.1 → 1.8.2

package/src/zexus/vm/vm.py

@@ -31,6 +31,7 @@ from ..object import (
     Map as ZMap,
     Null as ZNull,
     EvaluationError as ZEvaluationError,
+    DateTime as ZDateTime,
 )
 
 # ==================== Backend / Optional Imports ====================
@@ -782,6 +783,9 @@ class VM:
         vm.enable_fast_loop = getattr(parent_vm, "enable_fast_loop", False)
         vm.fast_loop_threshold = getattr(parent_vm, "fast_loop_threshold", 512)
         vm._fast_loop_stats = {"used": False, "reason": ""}
+        # SECURITY (H9): Call-depth tracking for child VMs
+        vm._call_depth = 0
+        vm._MAX_CALL_DEPTH = getattr(parent_vm, "_MAX_CALL_DEPTH", 256)
         
         # Settings
         vm.worker_count = parent_vm.worker_count
@@ -921,6 +925,82 @@ class VM:
             self.builtins["__vm_use_module__"] = self._vm_use_module
         if "__vm_from_module__" not in self.builtins:
             self.builtins["__vm_from_module__"] = self._vm_from_module
+        # Channel builtins for VM concurrency support
+        if "__create_channel__" not in self.builtins:
+            self.builtins["__create_channel__"] = self._vm_create_channel
+        if "send" not in self.builtins:
+            self.builtins["send"] = self._vm_send
+        if "receive" not in self.builtins:
+            self.builtins["receive"] = self._vm_receive
+        if "close_channel" not in self.builtins:
+            self.builtins["close_channel"] = self._vm_close_channel
+
+    # --- Channel builtins for VM ---
+    def _vm_create_channel(self, name, element_type=None, capacity=0):
+        """Create a channel and store it in the VM environment."""
+        try:
+            from ..concurrency_system import Channel
+        except ImportError:
+            # Fallback: use a simple queue-based channel
+            import queue as _queue_mod
+
+            class _SimpleChannel:
+                def __init__(self, name, capacity=0):
+                    self.name = name
+                    self._queue = _queue_mod.Queue(maxsize=capacity if capacity else 0)
+                    self._closed = False
+
+                def send(self, value, timeout=5.0):
+                    if self._closed:
+                        raise RuntimeError(f"Channel '{self.name}' is closed")
+                    self._queue.put(value, timeout=timeout)
+
+                def receive(self, timeout=5.0):
+                    if self._closed and self._queue.empty():
+                        return None
+                    try:
+                        return self._queue.get(timeout=timeout)
+                    except _queue_mod.Empty:
+                        return None
+
+                def close(self):
+                    self._closed = True
+
+            Channel = _SimpleChannel
+
+        cap = int(capacity) if capacity else 0
+        ch = Channel(name=name, capacity=cap) if element_type is None else Channel(name=name, element_type=element_type, capacity=cap)
+        self.env[name] = ch
+        return ch
+
+    def _vm_send(self, channel, value):
+        """Send value to channel."""
+        if channel is None or not hasattr(channel, 'send'):
+            return None
+        try:
+            channel.send(value, timeout=5.0)
+        except Exception:
+            pass
+        return None
+
+    def _vm_receive(self, channel):
+        """Receive value from channel."""
+        if channel is None or not hasattr(channel, 'receive'):
+            return None
+        try:
+            return channel.receive(timeout=5.0)
+        except Exception:
+            return None
+
+    def _vm_close_channel(self, channel):
+        """Close a channel."""
+        if channel is None or not hasattr(channel, 'close'):
+            return None
+        try:
+            channel.close()
+        except Exception:
+            pass
+        return None
 
     def _vm_use_module(self, spec):
         if spec is None:
@@ -2027,15 +2107,32 @@ class VM:
                 a = stack_pop() if stack else 0
                 if hasattr(a, 'value'): a = a.value
                 if hasattr(b, 'value'): b = b.value
-                stack_append(a + b)
+                # Type coercion: if either operand is a string, convert both to string
+                if isinstance(a, str) or isinstance(b, str):
+                    stack_append(str(a if a is not None else '') + str(b if b is not None else ''))
+                else:
+                    if a is None: a = 0
+                    if b is None: b = 0
+                    stack_append(a + b)
             elif op_name == "SUB":
-                b = stack_pop() if stack else 0
-                a = stack_pop() if stack else 0
-                if hasattr(a, 'value'): a = a.value
-                if hasattr(b, 'value'): b = b.value
-                if a is None: a = 0
-                if b is None: b = 0
-                stack_append(a - b)
+                b_raw = stack_pop() if stack else 0
+                a_raw = stack_pop() if stack else 0
+                # DateTime arithmetic
+                if isinstance(a_raw, ZDateTime) and isinstance(b_raw, ZDateTime):
+                    stack_append(a_raw.timestamp - b_raw.timestamp)
+                elif isinstance(a_raw, ZDateTime):
+                    b = b_raw.value if hasattr(b_raw, 'value') else b_raw
+                    if b is None: b = 0
+                    stack_append(ZDateTime(a_raw.timestamp - float(b)))
+                else:
+                    a = a_raw.value if hasattr(a_raw, 'value') else a_raw
+                    b = b_raw.value if hasattr(b_raw, 'value') else b_raw
+                    if a is None: a = 0
+                    if b is None: b = 0
+                    try:
+                        stack_append(a - b)
+                    except TypeError:
+                        stack_append(0)
             elif op_name == "MUL":
                 b = stack_pop() if stack else 0
                 a = stack_pop() if stack else 0
@@ -2578,6 +2675,48 @@ class VM:
                     if caller and caller not in allowed:
                         raise ZEvaluationError(f"Access denied: '{r_key}' restricted to allowed addresses")
 
+            elif op_name == "SPAWN":
+                # Sync SPAWN: schedule the function to run in a background thread
+                import threading
+                val = stack_pop() if stack else None
+                if callable(val):
+                    # val is a callable — run it in a daemon thread
+                    t = threading.Thread(target=val, daemon=True)
+                    t.start()
+                    stack_append(t)
+                elif isinstance(val, dict) and "bytecode" in val:
+                    # val is a function descriptor — execute its bytecode in a thread
+                    func_desc = val
+                    def _run_func_desc(fd=func_desc):
+                        try:
+                            child_vm = VM.create_child(parent_vm=self, env=dict(env))
+                            child_vm._run_stack_bytecode_sync(fd["bytecode"], debug=False)
+                            self._return_vm_to_pool(child_vm)
+                        except Exception:
+                            pass
+                    t = threading.Thread(target=_run_func_desc, daemon=True)
+                    t.start()
+                    stack_append(t)
+                else:
+                    # Already a result (not spawnable) — just push it back
+                    stack_append(val)
+
+            elif op_name == "AWAIT":
+                import threading
+                val = stack_pop() if stack else None
+                if isinstance(val, threading.Thread):
+                    val.join(timeout=30)
+                    stack_append(None)
+                elif isinstance(val, str) and val in self._tasks:
+                    # asyncio task — run in event loop
+                    try:
+                        result = self._run_coroutine_sync(self._tasks[val])
+                        stack_append(result)
+                    except Exception:
+                        stack_append(None)
+                else:
+                    stack_append(val)
+
             else:
                 # Truly unknown op — fallback to async path
                 return self._run_coroutine_sync(self._run_stack_bytecode(bytecode, debug))
@@ -2693,16 +2832,18 @@ class VM:
         if fn is None:
             return None
         # SECURITY (H9): Enforce call-depth limit
-        if self._call_depth >= self._MAX_CALL_DEPTH:
+        call_depth = getattr(self, '_call_depth', 0)
+        max_depth = getattr(self, '_MAX_CALL_DEPTH', 256)
+        if call_depth >= max_depth:
             raise RecursionError(
-                f"VM call depth exceeded maximum ({self._MAX_CALL_DEPTH}). "
+                f"VM call depth exceeded maximum ({max_depth}). "
                 "Possible infinite recursion."
             )
-        self._call_depth += 1
+        self._call_depth = call_depth + 1
         try:
             return self._invoke_callable_sync_inner(fn, args)
         finally:
-            self._call_depth -= 1
+            self._call_depth = getattr(self, '_call_depth', 1) - 1
 
     def _invoke_callable_sync_inner(self, fn, args):
         """Inner implementation of callable invocation."""
@@ -3074,22 +3215,57 @@ class VM:
 
         def _binary_op(func):
             def wrapper(_):
-                b = _unwrap(stack.pop() if stack else 0)
-                a = _unwrap(stack.pop() if stack else 0)
-                if a is None: a = 0
-                if b is None: b = 0
+                b_raw = stack.pop() if stack else 0
+                a_raw = stack.pop() if stack else 0
+                # Keep raw objects for DateTime-aware arithmetic
+                a = _unwrap(a_raw)
+                b = _unwrap(b_raw)
                 if isinstance(a, ZEvaluationError):
                     stack.append(a)
                     return
                 if isinstance(b, ZEvaluationError):
                     stack.append(b)
                     return
+                # DateTime arithmetic
+                if isinstance(a_raw, ZDateTime) or isinstance(b_raw, ZDateTime):
+                    a_dt = a_raw if isinstance(a_raw, ZDateTime) else None
+                    b_dt = b_raw if isinstance(b_raw, ZDateTime) else None
+                    if a_dt and b_dt:
+                        # DateTime - DateTime = seconds difference
+                        stack.append(a_dt.timestamp - b_dt.timestamp)
+                    elif a_dt:
+                        # DateTime +/- number
+                        val = float(b) if b is not None else 0.0
+                        try:
+                            result = func(a_dt.timestamp, val)
+                            stack.append(ZDateTime(result))
+                        except Exception:
+                            stack.append(0)
+                    else:
+                        val = float(a) if a is not None else 0.0
+                        try:
+                            result = func(val, b_dt.timestamp)
+                            stack.append(result)
+                        except Exception:
+                            stack.append(0)
+                    return
+                if a is None: a = 0
+                if b is None: b = 0
+                # Type coercion for string concatenation in ADD
+                if isinstance(a, str) or isinstance(b, str):
+                    try:
+                        stack.append(func(a, b))
+                    except TypeError:
+                        stack.append(str(a) + str(b))
+                    return
                 try:
                     stack.append(func(a, b))
-                except Exception as exc:
-                    if os.environ.get("ZEXUS_VM_PROFILE_OPS"):
-                        print(f"[VM DEBUG] binary op error func={func} a={a!r} b={b!r} exc={exc}")
-                    raise
+                except TypeError:
+                    # Graceful fallback — coerce to strings
+                    try:
+                        stack.append(str(a) + str(b))
+                    except Exception:
+                        stack.append(0)
             return wrapper
 
         def _binary_bool_op(func):
@@ -3394,19 +3570,41 @@ class VM:
             stack.append(-a)
 
         def _op_add(_):
-            b = _unwrap(stack_pop() if stack else 0)
-            a = _unwrap(stack_pop() if stack else 0)
-            if a is None:
-                a = 0
-            if b is None:
-                b = 0
+            b_raw = stack_pop() if stack else 0
+            a_raw = stack_pop() if stack else 0
+            # DateTime arithmetic
+            if isinstance(a_raw, ZDateTime) or isinstance(b_raw, ZDateTime):
+                a_dt = a_raw if isinstance(a_raw, ZDateTime) else None
+                b_dt = b_raw if isinstance(b_raw, ZDateTime) else None
+                if a_dt and b_dt:
+                    stack_append(a_dt.timestamp + b_dt.timestamp)
+                elif a_dt:
+                    b = _unwrap(b_raw)
+                    if b is None: b = 0
+                    stack_append(ZDateTime(a_dt.timestamp + float(b)))
+                else:
+                    a = _unwrap(a_raw)
+                    if a is None: a = 0
+                    stack_append(ZDateTime(b_raw.timestamp + float(a)))
+                return
+            b = _unwrap(b_raw)
+            a = _unwrap(a_raw)
             if isinstance(a, ZEvaluationError):
                 stack_append(a)
                 return
             if isinstance(b, ZEvaluationError):
                 stack_append(b)
                 return
-            stack_append(a + b)
+            # Type coercion: if either operand is a string, convert both to string
+            if isinstance(a, str) or isinstance(b, str):
+                stack_append(str(a if a is not None else '') + str(b if b is not None else ''))
+            else:
+                if a is None: a = 0
+                if b is None: b = 0
+                try:
+                    stack_append(a + b)
+                except TypeError:
+                    stack_append(str(a) + str(b))
 
         def _op_not(_):
             a = stack.pop() if stack else False
@@ -4135,12 +4333,31 @@ class VM:
                     # Auto-unwrap evaluator objects
                     if hasattr(a, 'value'): a = a.value
                     if hasattr(b, 'value'): b = b.value
-                    stack.append(a + b)
+                    # Type coercion: if either operand is a string, convert both to string
+                    if isinstance(a, str) or isinstance(b, str):
+                        stack.append(str(a if a is not None else '') + str(b if b is not None else ''))
+                    else:
+                        if a is None: a = 0
+                        if b is None: b = 0
+                        stack.append(a + b)
                 elif op_name == "SUB":
-                    b = stack.pop() if stack else 0; a = stack.pop() if stack else 0
-                    if hasattr(a, 'value'): a = a.value
-                    if hasattr(b, 'value'): b = b.value
-                    stack.append(a - b)
+                    b_raw = stack.pop() if stack else 0; a_raw = stack.pop() if stack else 0
+                    # DateTime arithmetic
+                    if isinstance(a_raw, ZDateTime) and isinstance(b_raw, ZDateTime):
+                        stack.append(a_raw.timestamp - b_raw.timestamp)
+                    elif isinstance(a_raw, ZDateTime):
+                        b = b_raw.value if hasattr(b_raw, 'value') else b_raw
+                        if b is None: b = 0
+                        stack.append(ZDateTime(a_raw.timestamp - float(b)))
+                    else:
+                        a = a_raw.value if hasattr(a_raw, 'value') else a_raw
+                        b = b_raw.value if hasattr(b_raw, 'value') else b_raw
+                        if a is None: a = 0
+                        if b is None: b = 0
+                        try:
+                            stack.append(a - b)
+                        except TypeError:
+                            stack.append(0)
                 elif op_name == "MUL":
                     b = stack.pop() if stack else 0; a = stack.pop() if stack else 0
                     if hasattr(a, 'value'): a = a.value

package/src/zexus/zpm/package_manager.py

@@ -23,7 +23,7 @@ class PackageManager:
         self.installer = PackageInstaller(self.zpm_dir)
         self.publisher = PackagePublisher(self.registry)
         
-    def init(self, name: str = None, version: str = "1.8.1") -> Dict:
+    def init(self, name: str = None, version: str = "1.8.2") -> Dict:
         """Initialize a new Zexus project with package.json"""
         if self.config_file.exists():
             print(f"⚠️  {self.config_file} already exists")

package/src/zexus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zexus
-Version: 1.8.1
+Version: 1.8.2
 Summary: A modern, security-first programming language with blockchain support
 Home-page: https://github.com/Zaidux/zexus-interpreter
 Author: Zaidux

package/src/zexus.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 .gitattributes
 .gitignore
+.npmignore
 ADDITIONAL_FIXES_1.6.7.md
 BLOCKCHAIN_MODULE_FULL_SOURCE.md
 CHANGELOG.md
@@ -165,18 +166,25 @@ bin/zx-dev
 bin/zx-run
 blockchain_demo/address_prefix.zx
 blockchain_demo/dex.zx
+blockchain_demo/dex.zxc
 blockchain_demo/governance.zx
+blockchain_demo/governance.zxc
 blockchain_demo/main.zx
 blockchain_demo/multichain_bridge.zx
 blockchain_demo/nft.zx
+blockchain_demo/nft.zxc
 blockchain_demo/staking.zx
+blockchain_demo/staking.zxc
 blockchain_demo/test_import_closure.zx
 blockchain_demo/test_module.zx
 blockchain_demo/test_utils_import.zx
 blockchain_demo/test_utils_import2.zx
 blockchain_demo/token.zx
+blockchain_demo/token.zxc
 blockchain_demo/utils.zx
+blockchain_demo/utils.zxc
 blockchain_demo/wallet.zx
+blockchain_demo/wallet.zxc
 blockchain_test/PARSER_FIX_DATA_DECLARATIONS.md
 blockchain_test/PERFORMANCE_ANALYSIS.md
 blockchain_test/PERFORMANCE_FINAL_REPORT.md
@@ -583,6 +591,7 @@ src/zexus/zexus_token.py
 src/zexus.egg-info/PKG-INFO
 src/zexus.egg-info/SOURCES.txt
 src/zexus.egg-info/dependency_links.txt
+src/zexus.egg-info/entry_points.txt
 src/zexus.egg-info/not-zip-safe
 src/zexus.egg-info/requires.txt
 src/zexus.egg-info/top_level.txt

package/src/zexus.egg-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+zexus = zexus.cli.main:cli
+zpics = zexus.cli.main:cli
+zpm = zexus.cli.zpm:cli
+zx = zexus.cli.main:cli
+zx-deploy = zexus.cli.main:cli
+zx-dev = zexus.cli.main:cli
+zx-run = zexus.cli.main:cli