inscript-lang 2.1.2__tar.gz → 2.3.0__tar.gz

{inscript_lang-2.1.2 → inscript_lang-2.3.0}/PKG-INFO

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

{inscript_lang-2.1.2 → inscript_lang-2.3.0}/ast_nodes.py

@@ -735,3 +735,24 @@ class SelectStmt(Node):
     Each clause: {"kind": "recv"/"send"/"timeout", "var":str|None, "channel":expr|None, "value":expr|None, "duration":expr|None, "body":BlockStmt}
     """
     clauses: list   # list of clause dicts
+
+# ── v2.2.0 new nodes ─────────────────────────────────────────────────────────
+
+@dataclass
+class WithExpr(Node):
+    """with expr { .field = val, ... }  — clone-and-modify pattern."""
+    obj:    object   # expression producing the base object
+    fields: list     # list of (str field_name, expr value)
+
+@dataclass
+class DestructParam(Node):
+    """Destructuring parameter: fn f({x, y}: Point) or fn f([head, ...tail]: [])"""
+    kind:     str    # 'dict' or 'array'
+    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.1.2 → inscript_lang-2.3.0}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "2.1.2"
+VERSION = "2.3.0"
 
 MANIFEST_FILENAME = "inscript.toml"
 LOCK_FILENAME     = "inscript.lock"

{inscript_lang-2.1.2 → inscript_lang-2.3.0}/inscript_lang.egg-info/PKG-INFO

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

{inscript_lang-2.1.2 → inscript_lang-2.3.0}/interpreter.py

@@ -421,13 +421,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),
@@ -1080,6 +1083,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)
@@ -1950,7 +1977,13 @@ class Interpreter(Visitor):
         op  = node.op
         target = node.target
 
-        if op != "=":
+        if op == "??=":
+            # v2.2.0: null-coalescing assignment — only assign if current value is nil
+            cur = self.visit(target)
+            if cur is not None:
+                return cur      # already non-nil, do nothing
+            # fall through to write val
+        elif op != "=":
             # Compound assignment: strip '=' to get operator ("+=" → "+", "**=" → "**")
             cur = self.visit(target)
             sym_op = op.rstrip("=")
@@ -2314,6 +2347,22 @@ class Interpreter(Visitor):
                     if getattr(param, 'is_variadic', False):
                         env.define(param.name, avs[i:]); break
                     val = avs[i] if i < len(avs) else (self.visit(param.default) if param.default else None)
+                    # v2.2.0: DestructParam — dict or array destructuring
+                    from ast_nodes import DestructParam as _DP
+                    if isinstance(param, _DP):
+                        if param.kind == 'dict':
+                            src = val if isinstance(val, dict) else (val.__dict__ if hasattr(val, '__dict__') else {})
+                            for fname in param.names:
+                                env.define(fname, src.get(fname))
+                            if param.rest:
+                                env.define(param.rest, {k: v for k, v in src.items() if k not in param.names})
+                        else:  # array
+                            src = list(val) if val is not None else []
+                            for j, fname in enumerate(param.names):
+                                env.define(fname, src[j] if j < len(src) else None)
+                            if param.rest:
+                                env.define(param.rest, src[len(param.names):])
+                        continue
                     if param.type_ann and val is not None:
                         ann_name = param.type_ann.name
                         if ann_name in generic_bindings:
@@ -2502,11 +2551,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):
@@ -2516,17 +2564,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)
@@ -2677,6 +2785,29 @@ class Interpreter(Visitor):
         val = self.visit(node.left)
         return self.visit(node.right) if val is None else val
 
+    def visit_WithExpr(self, node) -> Any:
+        """v2.2.0: with obj { .field = val, ... } — clone and modify."""
+        from stdlib_values import InScriptInstance
+        base = self.visit(node.obj)
+        if isinstance(base, InScriptInstance):
+            clone = InScriptInstance(
+                struct_name=base.struct_name,
+                fields=dict(base.fields),
+            )
+        elif isinstance(base, dict):
+            clone = dict(base)
+        else:
+            import copy; clone = copy.copy(base)
+        for field_name, val_expr in node.fields:
+            val = self.visit(val_expr)
+            if isinstance(clone, InScriptInstance):
+                clone.fields[field_name] = val
+            elif isinstance(clone, dict):
+                clone[field_name] = val
+            else:
+                _set_attr(clone, field_name, val, node.line, self)
+        return clone
+
     def visit_PipeExpr(self, node: PipeExpr) -> Any:
         """value |> fn — calls fn(value)."""
         val = self.visit(node.value)
@@ -2824,6 +2955,41 @@ def _arr_count(lst, fn_or_val, interp):
 
 
 def _get_attr(obj: Any, name: str, line: int, interp: Interpreter) -> Any:
+    # v2.3.0: concurrency primitive attribute dispatch
+    from stdlib_values import InScriptTask, InScriptChannel, InScriptMutex, InScriptRWLock, InScriptTimerHandle
+
+    if isinstance(obj, InScriptTask):
+        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)
+
+    if isinstance(obj, 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)
+
+    if isinstance(obj, 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)
+
+    if isinstance(obj, 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)
+
+    if isinstance(obj, 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.1.2 → inscript_lang-2.3.0}/lexer.py

@@ -126,6 +126,7 @@ class TT(Enum):
     HASH        = auto()        # #   (attribute / annotation)
     AT          = auto()        # @   (decorator)
     NULLISH     = auto()        # ??  (nullish coalescing)
+    NULLISH_EQ  = auto()        # ??= (null-coalescing assignment)  v2.2.0
     QUESTION_DOT= auto()        # ?.  (optional chaining)
     PIPE_GT     = auto()        # |>  (pipe operator)
     FSTRING     = auto()        # f"..." (interpolated string — value is raw template)
@@ -574,7 +575,9 @@ class Lexer:
             if self.match(":"): emit(TT.DOUBLE_COLON, "::")
             else:               emit(TT.COLON,         ":")
         elif ch == "?":
-            if self.match("?"):  emit(TT.NULLISH,       "??")
+            if self.match("?"):
+                if self.match("="): emit(TT.NULLISH_EQ,   "??=")   # v2.2.0
+                else:               emit(TT.NULLISH,       "??")
             elif self.match("."): emit(TT.QUESTION_DOT, "?.")
             else:                emit(TT.QUESTION,       "?")
         elif ch == "#":

{inscript_lang-2.1.2 → inscript_lang-2.3.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 ---
@@ -402,8 +408,24 @@ class Parser:
         line, col = self._pos()
 
         # Tuple type: (int, float)  — used for multiple return values
+        # v2.2.0: named return type (min: float, max: float)
         if self.check(TT.LPAREN):
             self.advance()  # consume '('
+            # Detect named tuple: (IDENT COLON ...)
+            if (self.current.type == TT.IDENT
+                    and self.peek.type == TT.COLON):
+                named_fields = []
+                while True:
+                    fname = self.expect_ident("Expected field name in named return type")
+                    self.expect(TT.COLON, "Expected ':' after field name")
+                    ftype = self.parse_type_annotation()
+                    named_fields.append((fname, ftype))
+                    if not self.match(TT.COMMA):
+                        break
+                self.expect(TT.RPAREN, "Expected ')' to close named return type")
+                ann = TypeAnnotation(name="NamedTuple", line=line, col=col)
+                ann.named_fields = named_fields
+                return ann
             # Just consume the tuple type contents and treat it as "Tuple"
             depth = 1
             while not self.is_at_end() and depth > 0:
@@ -416,12 +438,16 @@ class Parser:
             self.advance()  # consume final ')'
             return TypeAnnotation(name="Tuple", line=line, col=col)
 
-        # Array type: [int]
+        # Array type: [int]  or bare [] (any-element array)
         if self.match(TT.LBRACKET):
-            inner = self.parse_type_annotation()
-            self.expect(TT.RBRACKET, "Expected ']' to close array type")
-            ann = TypeAnnotation(name="Array", is_array=True,
-                                 generics=[inner], line=line, col=col)
+            if self.check(TT.RBRACKET):
+                self.advance()  # consume ']'  — bare [] means Array<any>
+                ann = TypeAnnotation(name="Array", is_array=True, line=line, col=col)
+            else:
+                inner = self.parse_type_annotation()
+                self.expect(TT.RBRACKET, "Expected ']' to close array type")
+                ann = TypeAnnotation(name="Array", is_array=True,
+                                     generics=[inner], line=line, col=col)
         # Dict type: {string: int}
         elif self.match(TT.LBRACE):
             key = self.parse_type_annotation()
@@ -647,6 +673,47 @@ class Parser:
         elif self.check(TT.ELLIPSIS):
             self.advance()   # consume '...'  (alias for variadic)
             is_variadic = True
+
+        # v2.2.0: dict destructuring param — fn f({x, y}: Point)
+        if self.check(TT.LBRACE):
+            self.advance()  # consume '{'
+            names = []
+            rest  = None
+            while not self.check(TT.RBRACE) and not self.check(TT.EOF):
+                if self.check(TT.ELLIPSIS):
+                    self.advance()
+                    rest = self.expect_ident("Expected rest name after '...'")
+                    break
+                names.append(self.expect_ident("Expected field name"))
+                self.match(TT.COMMA)
+            self.expect(TT.RBRACE, "Expected '}' to close destructuring param")
+            type_ann = None
+            if self.match(TT.COLON):
+                type_ann = self.parse_type_annotation()
+            from ast_nodes import DestructParam
+            return DestructParam(kind='dict', names=names, rest=rest,
+                                 type_ann=type_ann, line=line, col=col)
+
+        # v2.2.0: array destructuring param — fn f([head, ...tail]: [])
+        if self.check(TT.LBRACKET):
+            self.advance()  # consume '['
+            names = []
+            rest  = None
+            while not self.check(TT.RBRACKET) and not self.check(TT.EOF):
+                if self.check(TT.ELLIPSIS):
+                    self.advance()
+                    rest = self.expect_ident("Expected rest name after '...'")
+                    break
+                names.append(self.expect_ident("Expected element binding"))
+                self.match(TT.COMMA)
+            self.expect(TT.RBRACKET, "Expected ']' to close destructuring param")
+            type_ann = None
+            if self.match(TT.COLON):
+                type_ann = self.parse_type_annotation()
+            from ast_nodes import DestructParam
+            return DestructParam(kind='array', names=names, rest=rest,
+                                 type_ann=type_ann, line=line, col=col)
+
         name = self.expect_ident("Expected parameter name")
         type_ann = None
         if self.match(TT.COLON):
@@ -1418,6 +1485,7 @@ class Parser:
             TT.CARET_EQ:   "^=",
             TT.LSHIFT_EQ:  "<<=",
             TT.RSHIFT_EQ:  ">>=",
+            TT.NULLISH_EQ: "??=",   # v2.2.0
         }
 
         if self.current.type in ASSIGN_OPS:
@@ -1427,7 +1495,8 @@ class Parser:
 
             # Extract the binary operator from compound ops (strip trailing =)
             # e.g. "+=" → "+", "**=" → "**"
-            binop = op.rstrip("=") if op != "=" else None
+            # "??=" is special — not a binary op, handled by interpreter directly
+            binop = op.rstrip("=") if op not in ("=", "??=") else None
 
             # Determine which assignment node to create
             if isinstance(expr, IdentExpr):
@@ -1594,8 +1663,32 @@ class Parser:
         while self.check(TT.LT, TT.GT, TT.LTE, TT.GTE):
             op    = self.advance().value
             right = self.parse_shift()
-            left  = BinaryExpr(left=left, op=op, right=right,
-                                line=line, col=col)
+            node  = BinaryExpr(left=left, op=op, right=right,
+                               line=line, col=col)
+            # v2.2.0: chained comparisons — 0 < x < 10 → (0<x) and (x<10)
+            # If another comparison operator follows, desugar into `and`
+            if self.check(TT.LT, TT.GT, TT.LTE, TT.GTE):
+                left  = node   # left side of `and` is current comparison
+                # `right` becomes the new LHS for the next comparison
+                # We need to avoid evaluating `right` twice, but in a simple
+                # interpreter it's safe to reuse the same AST node (no side effects
+                # on simple expressions).  Build: node AND (right op next)
+                op2   = self.advance().value
+                right2 = self.parse_shift()
+                rhs   = BinaryExpr(left=right, op=op2, right=right2,
+                                   line=line, col=col)
+                left  = BinaryExpr(left=node, op="&&", right=rhs,
+                                   line=line, col=col)
+                while self.check(TT.LT, TT.GT, TT.LTE, TT.GTE):
+                    op3   = self.advance().value
+                    right3 = self.parse_shift()
+                    rhs3  = BinaryExpr(left=right2, op=op3, right=right3,
+                                       line=line, col=col)
+                    left  = BinaryExpr(left=left, op="&&", right=rhs3,
+                                       line=line, col=col)
+                    right2 = right3
+                return left
+            left = node
         return left
 
     def parse_shift(self) -> Node:
@@ -1730,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 '?.'
@@ -1879,6 +1992,25 @@ class Parser:
         # Grouped expression: (expr)  OR  Tuple: (expr, expr, ...)
         if tok.type == TT.LPAREN:
             self.advance()  # consume '('
+            # v2.2.0: named return tuple literal — (name: expr, name: expr, ...)
+            # Detect: IDENT COLON pattern at the start
+            if (self.current.type == TT.IDENT
+                    and self.peek.type == TT.COLON):
+                pairs = []
+                while True:
+                    key = self.expect_ident("Expected field name in named tuple")
+                    self.expect(TT.COLON, "Expected ':' after field name")
+                    val = self.parse_expr()
+                    pairs.append((key, val))
+                    if not self.match(TT.COMMA):
+                        break
+                self.expect(TT.RPAREN, "Expected ')' to close named tuple")
+                # Return as a DictLiteralExpr with string-key pairs
+                return DictLiteralExpr(
+                    pairs=[(StringLiteralExpr(value=k, line=line, col=col), v)
+                           for k, v in pairs],
+                    line=line, col=col
+                )
             first = self.parse_expr()
             if self.check(TT.COMMA):
                 # It's a tuple literal
@@ -1933,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()
@@ -1948,6 +2087,23 @@ class Parser:
                 self.advance()  # consume 'comptime'
                 body = self.parse_block()
                 return ComptimeExpr(body=body, line=line, col=col)
+            # v2.2.0: with expr { .field = val, ... } — clone-and-modify
+            if tok.value == "with":
+                self.advance()  # consume 'with'
+                obj = self.parse_postfix()
+                self.expect(TT.LBRACE, "Expected '{' after 'with <expr>'")
+                fields = []
+                while not self.check(TT.RBRACE) and not self.check(TT.EOF):
+                    self.expect(TT.DOT, "Expected '.field = val' inside with block")
+                    field_name = self.expect_ident("Expected field name after '.'")
+                    self.expect(TT.ASSIGN, "Expected '=' after field name in with block")
+                    val = self.parse_expr()
+                    fields.append((field_name, val))
+                    self.match(TT.COMMA)
+                    self.match(TT.NEWLINE) if hasattr(TT, 'NEWLINE') else None
+                self.expect(TT.RBRACE, "Expected '}' to close with block")
+                from ast_nodes import WithExpr
+                return WithExpr(obj=obj, fields=fields, line=line, col=col)
             return self.parse_ident_or_struct_init()
 
         # Type keywords used as constructors: Vec2(…) → these lex as IDENT anyway

{inscript_lang-2.1.2 → inscript_lang-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inscript-lang"
-version = "2.1.2"
+version = "2.3.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.1.2 → inscript_lang-2.3.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.1.2"
+VERSION = "2.3.0"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):

{inscript_lang-2.1.2 → inscript_lang-2.3.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.1.2 → inscript_lang-2.3.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>"