inscript-lang 2.2.0__tar.gz → 2.4.0__tar.gz

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.2.0
+Version: 2.4.0
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/ast_nodes.py

@@ -751,3 +751,8 @@ class DestructParam(Node):
     names:    list   # list of str (field/element names to bind)
     rest:     object # str name for rest element (...tail), or None
     type_ann: object # TypeAnnotation or None
+
+@dataclass
+class TaskSpawnExpr(Node):
+    """v2.3.0: spawn <expr> — run expression concurrently, return InScriptTask."""
+    expr: object

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "2.2.0"
+VERSION = "2.4.0"
 
 MANIFEST_FILENAME = "inscript.toml"
 LOCK_FILENAME     = "inscript.lock"
@@ -389,19 +389,166 @@ def info_package(pkg_name: str) -> int:
 
 
 def run_file(path: str, type_check: bool = True) -> int:
-    """Load and execute an InScript source file. Returns exit code."""
+    """Load and execute an InScript source file (or .ibc bytecode). Returns exit code."""
     if not os.path.exists(path):
         print(f"[InScript] Error: file not found: '{path}'", file=sys.stderr)
         return 1
+    # v2.4.0: transparent .ibc execution via bytecode VM
+    if path.endswith(".ibc"):
+        return _run_ibc(path)
     if not path.endswith(".ins"):
         print(f"[InScript] Warning: expected .ins extension, got '{path}'", file=sys.stderr)
-
     with open(path, "r", encoding="utf-8") as f:
         source = f.read()
-
     return run_source(source, filename=path, type_check=type_check)
 
 
+# ── v2.4.0: Real Bytecode Pipeline ───────────────────────────────────────────
+
+def _ibc_path_for(src: str, out: str | None = None) -> str:
+    if out:
+        return out
+    base = src[:-4] if src.endswith(".ins") else src
+    return base + ".ibc"
+
+
+def _compile_cmd(src_path: str, out_path, target: str,
+                 dce: bool, incremental: bool) -> int:
+    """v2.4.0: AOT-compile .ins → .ibc using the real register-based VM compiler."""
+    if not os.path.exists(src_path):
+        print(f"[InScript] compile: file not found: '{src_path}'", file=sys.stderr)
+        return 1
+
+    # WASM / native — honest stubs with roadmap info
+    if target in ("wasm", "native"):
+        print(f"[InScript] --target {target} is planned for v2.5.x.")
+        print(f"  WASM output:   requires LLVM/Emscripten toolchain")
+        print(f"  Native output: requires transpile-to-C pipeline")
+        print(f"  Today's target: inscript --compile {src_path} --target ibc")
+        return 0
+
+    dest = _ibc_path_for(src_path, out_path)
+
+    # Incremental: skip if .ibc is up to date
+    if incremental and os.path.exists(dest):
+        if os.path.getmtime(dest) >= os.path.getmtime(src_path):
+            print(f"[InScript] compile: {dest} is up to date (--incremental)")
+            return 0
+
+    with open(src_path, "r", encoding="utf-8") as f:
+        source = f.read()
+
+    # Parse + compile to FnProto bytecode
+    try:
+        from compiler import compile_source
+        from vm_code  import write_ibc
+        proto = compile_source(source, filename=src_path)
+    except Exception as e:
+        print(f"[InScript] compile error: {e}", file=sys.stderr)
+        return 1
+
+    # Dead-code elimination at the proto level
+    if dce:
+        n_removed = _dce_proto(proto)
+        if n_removed:
+            print(f"[InScript] DCE: pruned {n_removed} unreachable nested proto(s)")
+
+    # Write .ibc
+    try:
+        write_ibc(proto, dest)
+    except Exception as e:
+        print(f"[InScript] serialize error: {e}", file=sys.stderr)
+        return 1
+
+    src_size = os.path.getsize(src_path)
+    ibc_size = os.path.getsize(dest)
+    dce_tag  = " +DCE" if dce else ""
+    print(f"[InScript] compiled{dce_tag}: {src_path}  →  {dest}")
+    print(f"           source {src_size:,}B  →  bytecode {ibc_size:,}B  "
+          f"({ibc_size/src_size*100:.0f}% of source)")
+    return 0
+
+
+def _run_ibc(path: str) -> int:
+    """v2.4.0: Load and execute a pre-compiled .ibc bytecode file."""
+    try:
+        from vm_code import read_ibc
+        from vm      import VM
+        proto = read_ibc(path)
+    except ValueError as e:
+        print(f"[InScript] run: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"[InScript] run: failed to load '{path}': {e}", file=sys.stderr)
+        return 1
+    try:
+        vm = VM(filename=path)
+        vm.run(proto)
+        return 0
+    except Exception as e:
+        print(f"[InScript] runtime error: {e}", file=sys.stderr)
+        return 1
+
+
+def _dce_proto(proto) -> int:
+    """
+    v2.4.0: Dead-code elimination at the FnProto level.
+    Removes nested protos whose names are never referenced in the parent's
+    name table. Returns the number of protos removed.
+    """
+    if not proto.protos:
+        return 0
+    referenced = set(proto.names)
+    before = len(proto.protos)
+    # Recurse into survivors first
+    for sub in proto.protos:
+        _dce_proto(sub)
+    # Remove unreferenced nested protos
+    proto.protos = [p for p in proto.protos if p.name in referenced or p.name == "<main>"]
+    removed = before - len(proto.protos)
+    return removed
+
+
+def _dce_pass(program):
+    """AST-level DCE (used by test_v240 for unit-testing DCE logic)."""
+    from ast_nodes import FunctionDecl, IdentExpr, Program
+
+    referenced: set = set()
+
+    def _walk(node):
+        if node is None: return
+        if isinstance(node, IdentExpr):
+            referenced.add(node.name)
+            return
+        for attr in (vars(node).values() if hasattr(node, '__dict__') else []):
+            if hasattr(attr, '__dict__'):
+                _walk(attr)
+            elif isinstance(attr, list):
+                for item in attr:
+                    if hasattr(item, '__dict__'): _walk(item)
+            elif isinstance(attr, tuple):
+                for item in attr:
+                    if hasattr(item, '__dict__'): _walk(item)
+
+    for stmt in program.body:
+        _walk(stmt)
+
+    kept = []
+    removed = 0
+    for stmt in program.body:
+        if isinstance(stmt, FunctionDecl) and stmt.name not in referenced:
+            if not getattr(stmt, 'exported', False):
+                removed += 1
+                continue
+        kept.append(stmt)
+
+    if removed:
+        print(f"[InScript] DCE: eliminated {removed} unreferenced function(s)")
+    return Program(body=kept)
+
+
+
+
 # ─── v1.6.0 helpers ──────────────────────────────────────────────────────────
 
 def _find_ins_files(directory: str):
@@ -2108,12 +2255,35 @@ Examples:
                         help="Window height for --game mode (default: 600)")
     parser.add_argument("--fps",    type=int, default=60,
                         help="Target FPS for --game mode   (default: 60)")
+    # ── v2.4.0: compilation flags ────────────────────────────────────────────
+    parser.add_argument("--compile", metavar="FILE",
+                        help="v2.4.0: AOT-compile FILE.ins → FILE.ibc bytecode")
+    parser.add_argument("--output", "-o", metavar="OUT",
+                        help="v2.4.0: Output path for --compile (default: same dir as input)")
+    parser.add_argument("--target", metavar="TARGET", default="interpreter",
+                        choices=["interpreter", "wasm", "native", "ibc"],
+                        help="v2.4.0: Compilation target: interpreter (default), ibc, wasm, native")
+    parser.add_argument("--no-dce", action="store_true",
+                        help="v2.4.0: Disable dead-code elimination before compilation")
+    parser.add_argument("--incremental", action="store_true",
+                        help="v2.4.0: Skip recompile if .ibc is newer than source")
     args = parser.parse_args()
 
     if args.version:
         print(f"InScript {VERSION}")
         return
 
+    # ── v2.4.0: --compile ────────────────────────────────────────────────────
+    if args.compile:
+        import sys as _sys
+        _sys.exit(_compile_cmd(
+            src_path   = args.compile,
+            out_path   = args.output,
+            target     = args.target,
+            dce        = not args.no_dce,
+            incremental= args.incremental,
+        ) or 0)
+
     # ── inscript --fmt / --fmt-check / --fmt-dry-run ─────────────────────────
     if args.fmt or args.fmt_check or args.fmt_dry_run:
         try:

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/inscript_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.2.0
+Version: 2.4.0
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/interpreter.py

@@ -28,6 +28,9 @@ from errors import (
 # INTERPRETER
 # ─────────────────────────────────────────────────────────────────────────────
 
+# v2.4.0: sentinel for inline cache misses (faster than None since None is valid)
+_CACHE_MISS = object()
+
 class Interpreter(Visitor):
     """
     Tree-walking interpreter.  Visits each AST node and returns a Python value.
@@ -48,6 +51,9 @@ class Interpreter(Visitor):
         self._current_fn: object = None
         # v1.4.0: defer stack — list of exprs to run at end of current function
         self._deferred: list = []
+        # v2.4.0: inline caches — monomorphic site caching for hot paths
+        self._ic_struct_fields: dict = {}   # struct_name -> {field: default_idx}
+        self._ic_fn_lookup:     dict = {}   # fn_name -> InScriptFunction (global scope)
 
         self._register_builtins()
 
@@ -421,13 +427,16 @@ class Interpreter(Visitor):
             "is_bool":     lambda v: isinstance(v, bool),
             "is_array":    lambda v: isinstance(v, list),
             "is_dict":     lambda v: isinstance(v, dict),
-            # ── Concurrency (lightweight stubs, full impl via async/await) ─────
-            "thread":      lambda fn, *args: self._spawn_thread(fn, list(args)),
-            "channel":      lambda cap=0: {"_type":"channel","_channel":__import__("queue").SimpleQueue(),"_cap":int(cap)},
-            "make_channel": lambda cap=0: {"_type":"channel","_channel":__import__("queue").SimpleQueue(),"_cap":int(cap)},
-            "chan_send":    lambda ch, v: ch["_channel"].put(v) if isinstance(ch,dict) and "_channel" in ch else None,
-            "chan_recv":    lambda ch: ch["_channel"].get(timeout=5) if isinstance(ch,dict) and "_channel" in ch else None,
-            "sleep":       lambda s: __import__('time').sleep(s),
+            # ── Concurrency v2.3.0 ───────────────────────────────────────────
+            "thread":       lambda fn, *args: self._spawn_thread(fn, list(args)),
+            "channel":      lambda cap=0: __import__('stdlib_values').InScriptChannel(int(cap) if cap else 0),
+            "make_channel": lambda cap=0: __import__('stdlib_values').InScriptChannel(int(cap) if cap else 0),
+            "chan_send":     lambda ch, v: ch.send(v) if hasattr(ch, 'send') else (ch["_channel"].put(v) if isinstance(ch, dict) and "_channel" in ch else None),
+            "chan_recv":     lambda ch: ch.recv() if hasattr(ch, 'recv') else (ch["_channel"].get(timeout=5) if isinstance(ch, dict) and "_channel" in ch else None),
+            "chan_try_recv": lambda ch: ch.try_recv() if hasattr(ch, 'try_recv') else None,
+            "mutex":        lambda v=None: __import__('stdlib_values').InScriptMutex(v),
+            "rwlock":       lambda v=None: __import__('stdlib_values').InScriptRWLock(v),
+            "sleep":        lambda s: __import__('time').sleep(s),
             # ── JSON ──────────────────────────────────────────────────────────
             "json_encode": lambda v: __import__('json').dumps(v),
             "json_decode": lambda s: __import__('json').loads(s),
@@ -530,6 +539,8 @@ class Interpreter(Visitor):
         # v1.9.7: mark async functions
         fn.is_async     = getattr(node, 'is_async', False)
         self._env.define(node.name, fn)
+        # v2.4.0: invalidate inline cache if this function was cached
+        self._ic_fn_lookup.pop(node.name, None)
         return fn
 
     def visit_GeneratorFnDecl(self, node) -> Any:
@@ -1080,6 +1091,30 @@ class Interpreter(Visitor):
         if isinstance(iterable, dict) and iterable.get("_enum_definition"):
             variants = [v for k, v in iterable.items() if not k.startswith("_")]
             iterable = variants
+        # v2.3.0: async for var in channel { } — drain channel until closed
+        from stdlib_values import InScriptChannel as _ISCh
+        if isinstance(iterable, _ISCh) and getattr(node, '_async_iter', False):
+            while not (iterable.closed and iterable._q.empty()):
+                val = iterable.try_recv()
+                if val is None:
+                    if iterable.closed:
+                        break
+                    import time as _t; _t.sleep(0.001)
+                    continue
+                self._push("for")
+                self._env.define(node.var_name, val)
+                try:
+                    self._exec_block_no_scope(node.body)
+                except BreakSignal as sig:
+                    self._pop()
+                    if sig.label: raise
+                    break
+                except ContinueSignal as sig:
+                    self._pop()
+                    if sig.label: raise
+                    continue
+                self._pop()
+            return
         # Support list, range, InScriptRange, string, dict, generator
         if isinstance(iterable, InScriptRange):
             it = iter(iterable)
@@ -1547,10 +1582,18 @@ class Interpreter(Visitor):
                     decl = None
                 parent_decl = getattr(decl, '_resolved_parent', None)
                 if parent_decl is not None:
-                    # Return a SuperProxy that knows the parent and self
                     return _SuperProxy(self_val, parent_decl, self)
             self._error("'super' only valid in a struct that extends another", node.line)
-        return self._env.get(node.name, node.line)
+        # v2.4.0: inline cache — fast path for global function lookups
+        name = node.name
+        ic = self._ic_fn_lookup.get(name)
+        if ic is not None:
+            return ic
+        val = self._env.get(name, node.line)
+        # Populate cache for top-level InScriptFunctions (stable globals only)
+        if isinstance(val, InScriptFunction) and self._env is self._globals:
+            self._ic_fn_lookup[name] = val
+        return val
 
     def visit_ArrayLiteralExpr(self, node: ArrayLiteralExpr) -> Any:
         result = []
@@ -2010,6 +2053,11 @@ class Interpreter(Visitor):
 
     def visit_GetAttrExpr(self, node: GetAttrExpr) -> Any:
         obj = self.visit(node.obj)
+        # v2.4.0: inline cache for struct field access — skip full _get_attr for hot path
+        if isinstance(obj, InScriptInstance):
+            val = obj.fields.get(node.attr, _CACHE_MISS)
+            if val is not _CACHE_MISS:
+                return val
         return _get_attr(obj, node.attr, node.line, self)
 
     def visit_IndexExpr(self, node: IndexExpr) -> Any:
@@ -2524,11 +2572,10 @@ class Interpreter(Visitor):
 
     def visit_AwaitExpr(self, node: AwaitExpr) -> Any:
         """
-        v1.9.7: True async/await.
-        - InScriptCoroutine → drive via Python coroutine protocol (sync driver).
-        - Plain value → passthrough (backwards compatible).
-        - Exceptions from inside the coroutine are converted to InScriptRuntimeError
-          so they are catchable by InScript try/catch blocks.
+        v2.3.0: await <expr>
+        InScript async fns return InScriptCoroutine. We drive them to completion
+        using send(None) — the coroutine body runs synchronously and raises
+        StopIteration(result) immediately (InScript has no real IO yields).
         """
         val = self.visit(node.expr)
         if isinstance(val, InScriptCoroutine):
@@ -2538,17 +2585,77 @@ class Interpreter(Visitor):
             except StopIteration as e:
                 return e.value
             except InScriptRuntimeError:
-                raise   # already an InScript error, let it propagate
+                raise
             except Exception as e:
-                # Convert Python exceptions to InScriptRuntimeError so
-                # they are catchable by InScript try/catch blocks.
                 err = InScriptRuntimeError(str(e), getattr(node, 'line', 0))
                 err.thrown_value = str(e)
                 raise err
-        return val   # plain value: passthrough
+        return val   # plain value passthrough
 
-    def visit_SpawnExpr(self, node: SpawnExpr) -> Any:
-        return None   # Phase 6 (ECS)
+    def visit_SpawnExpr(self, node) -> Any:
+        """ECS spawn — handled by game backend; stub in core interpreter."""
+        return None
+
+    def visit_TaskSpawnExpr(self, node) -> Any:
+        """v2.3.0: spawn <expr> — run in background thread, return InScriptTask."""
+        from stdlib_values import InScriptTask
+        expr_val = self.visit(node.expr)
+        if isinstance(expr_val, InScriptCoroutine):
+            coro = expr_val.coro
+            def _run_coro():
+                try:
+                    coro.send(None)
+                except StopIteration as e:
+                    return e.value
+                return None
+            task = InScriptTask(_run_coro, None)
+        elif callable(expr_val):
+            fn = expr_val
+            def _run_fn():
+                return self._call_fn(fn, [])
+            task = InScriptTask(_run_fn, None)
+        else:
+            val = expr_val
+            task = InScriptTask(lambda: val, None)
+        return task
+
+    def visit_SelectStmt(self, node) -> Any:
+        """v2.3.0: select { case x = ch.recv() { } case ch.send(v) { } case timeout(t) { } }"""
+        from stdlib_values import InScriptChannel
+        from ast_nodes import CallExpr, GetAttrExpr
+        for clause in node.clauses:
+            kind = clause.get("kind")
+            if kind == "recv":
+                # clause["channel"] is CallExpr(callee=GetAttr(ch, "recv"), args=[])
+                call_expr = clause.get("channel")
+                if call_expr and isinstance(call_expr, CallExpr):
+                    ch = self.visit(call_expr.callee.obj)
+                else:
+                    ch = None
+                if isinstance(ch, InScriptChannel):
+                    val = ch.try_recv()
+                    if val is not None:
+                        var = clause.get("var")
+                        if var:
+                            self._env.define(var, val)
+                        self.visit(clause["body"])
+                        return
+            elif kind == "send":
+                # clause["channel"] is CallExpr(callee=GetAttr(ch, "send"), args=[val])
+                call_expr = clause.get("channel")
+                if call_expr and isinstance(call_expr, CallExpr):
+                    ch  = self.visit(call_expr.callee.obj)
+                    val = self.visit(call_expr.args[0].value) if call_expr.args else None
+                else:
+                    ch = val = None
+                if isinstance(ch, InScriptChannel) and not ch._q.full():
+                    ch.send(val)
+                    self.visit(clause["body"])
+                    return
+            elif kind == "timeout":
+                # Timeout clause fires as fallback — always last resort
+                self.visit(clause["body"])
+                return
 
     def visit_MatchArm(self, node: MatchArm) -> Any:
         return self.visit(node.body)
@@ -2869,6 +2976,38 @@ def _arr_count(lst, fn_or_val, interp):
 
 
 def _get_attr(obj: Any, name: str, line: int, interp: Interpreter) -> Any:
+    # v2.3.0/v2.4.0: concurrency primitive attribute dispatch
+    # Only import when obj is one of the concurrency types (type-name fast check)
+    _tname = type(obj).__name__
+    if _tname == "InScriptTask":
+        import stdlib_values as _sv
+        if name == "join":   return lambda timeout=None: obj.join(timeout)
+        if name == "done":   return obj.done
+        if name == "result": return obj._result
+        interp._error(f"Task has no member '{name}'. Available: join, done, result", line)
+    elif _tname == "InScriptChannel":
+        if name == "send":      return lambda v: obj.send(v)
+        if name == "recv":      return lambda: obj.recv()
+        if name == "try_recv":  return lambda: obj.try_recv()
+        if name == "close":     return lambda: obj.close()
+        if name == "closed":    return obj.closed
+        if name == "size":      return obj._q.qsize()
+        if name == "is_empty":  return obj._q.empty()
+        interp._error(f"Channel has no member '{name}'. Available: send, recv, try_recv, close, closed, size", line)
+    elif _tname == "InScriptMutex":
+        if name == "lock":  return lambda fn: obj.lock(lambda args: interp._call_fn(fn, args))
+        if name == "set":   return lambda v: obj.set(v)
+        if name == "value": return obj.value
+        interp._error(f"Mutex has no member '{name}'. Available: lock, set, value", line)
+    elif _tname == "InScriptRWLock":
+        if name == "read":  return lambda fn: obj.read(lambda args: interp._call_fn(fn, args))
+        if name == "write": return lambda fn: obj.write(lambda args: interp._call_fn(fn, args))
+        if name == "value": return obj.value
+        interp._error(f"RWLock has no member '{name}'. Available: read, write, value", line)
+    elif _tname == "InScriptTimerHandle":
+        if name == "cancel": return lambda: obj.cancel()
+        interp._error(f"TimerHandle has no member '{name}'. Available: cancel", line)
+
     # StructDecl used as namespace for static method access: M.sq(5)
     if isinstance(obj, StructDecl):
         if hasattr(obj, '_static_ns') and name in obj._static_ns:

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/parser.py

@@ -147,6 +147,12 @@ class Parser:
 
         # --- Async/Await ---
         if tok.type == TT.ASYNC:
+            # v2.3.0: async for var in channel { } — iterate over async iterable
+            if self.peek.type == TT.FOR:
+                self.advance()  # consume 'async'
+                node = self.parse_for_in()
+                node._async_iter = True  # flag for interpreter
+                return node
             return self.parse_async_fn()
 
         # --- Await expr ---
@@ -1817,6 +1823,26 @@ class Parser:
                 args = self.parse_arg_list()
                 expr = CallExpr(callee=expr, args=args, line=line, col=col)
 
+            # v2.3.0: generic builtin call: channel<T>(cap) / Stack<T>() etc.
+            # Pattern: IDENT < TYPE_OR_IDENT > (
+            elif (self.check(TT.LT)
+                  and isinstance(expr, IdentExpr)
+                  and self.peek.type in (TT.INT_TYPE, TT.FLOAT_TYPE, TT.STRING_TYPE,
+                                         TT.BOOL_TYPE, TT.IDENT, TT.VOID_TYPE)):
+                saved = self.pos
+                self.advance()  # consume '<'
+                self.advance()  # consume type name
+                if self.check(TT.GT):
+                    self.advance()  # consume '>'
+                    if self.check(TT.LPAREN):
+                        # It's a generic call — type param is stripped (runtime ignores it)
+                        args = self.parse_arg_list()
+                        expr = CallExpr(callee=expr, args=args, line=line, col=col)
+                        continue
+                # Not a generic call — backtrack and stop postfix chain
+                self.pos = saved
+                break
+
             # Optional chaining: expr?.member  or  expr?.method(args)
             elif self.check(TT.QUESTION_DOT):
                 self.advance()  # consume '?.'
@@ -2039,6 +2065,13 @@ class Parser:
             expr = self.parse_unary()
             return AwaitExpr(expr=expr, line=line, col=col)
 
+        # v2.3.0: spawn <expr> — concurrency task
+        if tok.type == TT.SPAWN:
+            self.advance()  # consume 'spawn'
+            expr = self.parse_unary()
+            from ast_nodes import TaskSpawnExpr
+            return TaskSpawnExpr(expr=expr, line=line, col=col)
+
         # try { expr } catch e { expr } — try as expression (returns value)
         if tok.type == TT.TRY:
             return self._parse_try_expr()

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inscript-lang"
-version = "2.2.0"
+version = "2.4.0"
 description = "InScript — a game-focused scripting language with 59 game modules and a bytecode VM"
 readme = "README.md"
 license = { text = "MIT" }

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/repl.py

@@ -40,7 +40,7 @@ sys.path.insert(0, str(Path(__file__).parent))
 
 HISTORY_FILE = Path.home() / ".inscript" / "history"
 HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
-VERSION = "2.2.0"
+VERSION = "2.4.0"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/stdlib.py

@@ -1063,8 +1063,79 @@ except KeyError:
         "sleep_sync": _timer_sleep_sync,  # synchronous fallback
         "now":        lambda: int(_time_mod.time() * 1000),  # ms since epoch
         "now_sec":    lambda: _time_mod.time(),              # seconds since epoch
+        # v2.3.0: after / every / cancel
+        "after":      None,   # patched below
+        "every":      None,   # patched below
+        "cancel":     None,   # patched below
     })
 
+# v2.3.0: patch timer.after / timer.every / timer.cancel
+try:
+    import threading as _thr_mod
+    from stdlib_values import InScriptTimerHandle as _THndl
+
+    def _timer_after(ms, fn):
+        """timer.after(ms, fn) — call fn() once after ms milliseconds."""
+        def _fire():
+            try: fn([])
+            except Exception: pass
+        t = _thr_mod.Timer(int(ms) / 1000.0, _fire)
+        t.daemon = True
+        t.start()
+        return _THndl(t)
+
+    def _timer_every(ms, fn):
+        """timer.every(ms, fn) — call fn() every ms milliseconds until cancelled."""
+        handle = [None]
+        def _tick():
+            try: fn([])
+            except Exception: pass
+            t = _thr_mod.Timer(int(ms) / 1000.0, _tick)
+            t.daemon = True
+            handle[0] = t
+            t.start()
+        t0 = _thr_mod.Timer(int(ms) / 1000.0, _tick)
+        t0.daemon = True
+        handle[0] = t0
+        t0.start()
+        class _EveryHandle:
+            def cancel(self): handle[0] and handle[0].cancel()
+            def __repr__(self): return "<TimerHandle periodic>"
+        return _EveryHandle()
+
+    def _timer_cancel(handle):
+        if hasattr(handle, 'cancel'): handle.cancel()
+
+    _MODULES["timer"]["after"]  = _timer_after
+    _MODULES["timer"]["every"]  = _timer_every
+    _MODULES["timer"]["cancel"] = _timer_cancel
+except Exception as _te:
+    pass
+
+# v2.3.0: channel, mutex, rwlock as global builtins
+try:
+    from stdlib_values import InScriptChannel as _ISChannel
+    from stdlib_values import InScriptMutex   as _ISMutex
+    from stdlib_values import InScriptRWLock  as _ISRWLock
+
+    def _make_channel(capacity=0):
+        cap = capacity[0] if isinstance(capacity, list) and capacity else (capacity or 0)
+        return _ISChannel(int(cap))
+
+    def _make_mutex(value=None):
+        v = value[0] if isinstance(value, list) and value else value
+        return _ISMutex(v)
+
+    def _make_rwlock(value=None):
+        v = value[0] if isinstance(value, list) and value else value
+        return _ISRWLock(v)
+
+    # Register as global builtins (not modules)
+    # channel/mutex/rwlock are registered directly in the interpreter globals (interpreter.py)
+    pass
+except Exception as _ce:
+    pass
+
 
 
 # ── Extended stdlib (Part 1): collections, datetime, fs, process, log, test, compress

{inscript_lang-2.2.0 → inscript_lang-2.4.0}/stdlib_values.py

@@ -326,3 +326,151 @@ class InScriptGenerator:
         except StopIteration:
             self._done = True
             return None
+
+
+# ── v2.3.0: Concurrency primitives ───────────────────────────────────────────
+
+import threading as _threading
+import queue as _queue
+
+class InScriptTask:
+    """
+    v2.3.0: Handle returned by `spawn expr`.
+    Runs a callable in a background thread.
+    """
+    def __init__(self, fn, args):
+        self._result  = None
+        self._error   = None
+        self._done    = _threading.Event()
+        self._thread  = _threading.Thread(target=self._run, args=(fn, args), daemon=True)
+        self._thread.start()
+
+    def _run(self, fn, args):
+        try:
+            self._result = fn()
+        except Exception as e:
+            self._error = e
+        finally:
+            self._done.set()
+
+    def join(self, timeout=None):
+        """Block until task completes. Returns result or raises."""
+        self._done.wait(timeout)
+        if self._error:
+            raise self._error
+        return self._result
+
+    @property
+    def done(self):
+        return self._done.is_set()
+
+    def __repr__(self):
+        return f"<Task {'done' if self.done else 'running'}>"
+
+
+class InScriptChannel:
+    """
+    v2.3.0: `channel<T>(capacity)` — typed message-passing queue.
+    .send(v)       — put value (blocks if full, capacity=0 means unbounded)
+    .recv()        — get value (blocks until available)
+    .try_recv()    — get value or nil (non-blocking)
+    .close()       — mark channel closed
+    .closed        — bool
+    """
+    def __init__(self, capacity: int = 0):
+        self._q      = _queue.Queue(maxsize=capacity)
+        self._closed = False
+
+    def send(self, value):
+        if self._closed:
+            raise RuntimeError("send on closed channel")
+        self._q.put(value)
+
+    def recv(self):
+        return self._q.get()
+
+    def try_recv(self):
+        try:
+            return self._q.get_nowait()
+        except _queue.Empty:
+            return None
+
+    def close(self):
+        self._closed = True
+
+    @property
+    def closed(self):
+        return self._closed
+
+    def __repr__(self):
+        return f"<Channel size={self._q.qsize()} closed={self._closed}>"
+
+
+class InScriptMutex:
+    """
+    v2.3.0: `mutex(value)` — thread-safe value wrapper.
+    .lock(fn)    — call fn(value) under lock, returns fn's result
+    .value       — read current value (unsafe, prefer lock())
+    .set(v)      — set value under lock
+    """
+    def __init__(self, value):
+        self._value = value
+        self._lock  = _threading.Lock()
+
+    def lock(self, fn):
+        with self._lock:
+            result = fn([self._value]) if callable(fn) else None
+            return result
+
+    def set(self, value):
+        with self._lock:
+            self._value = value
+
+    @property
+    def value(self):
+        return self._value
+
+    def __repr__(self):
+        return f"<Mutex value={self._value!r}>"
+
+
+class InScriptRWLock:
+    """
+    v2.3.0: `rwlock(value)` — reader/writer lock.
+    .read(fn)    — call fn(value) under read lock
+    .write(fn)   — call fn(value) under write lock, fn may return new value
+    """
+    def __init__(self, value):
+        self._value  = value
+        self._lock   = _threading.RLock()   # simplified: use reentrant lock
+
+    def read(self, fn):
+        with self._lock:
+            return fn([self._value]) if callable(fn) else self._value
+
+    def write(self, fn):
+        with self._lock:
+            result = fn([self._value]) if callable(fn) else None
+            if result is not None:
+                self._value = result
+            return result
+
+    @property
+    def value(self):
+        return self._value
+
+    def __repr__(self):
+        return f"<RWLock value={self._value!r}>"
+
+
+class InScriptTimerHandle:
+    """Handle returned by timer.after / timer.every for cancellation."""
+    def __init__(self, timer_obj):
+        self._timer = timer_obj   # threading.Timer or periodic wrapper
+
+    def cancel(self):
+        if hasattr(self._timer, 'cancel'):
+            self._timer.cancel()
+
+    def __repr__(self):
+        return "<TimerHandle>"