inscript-lang 1.6.0__tar.gz → 1.7.3__tar.gz

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/PKG-INFO

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

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/errors.py

@@ -53,6 +53,9 @@ ERROR_CODES = {
     "MatchError":              "E0047",
     "PropertyError":           "E0048",
     "NilAccess":               "E0049",
+
+    # Deprecated-keyword hard errors (v1.7.4)
+    "NullKeyword":             "E0055",
 }
 
 DOCS_BASE = "https://docs.inscript.dev/errors"
@@ -103,11 +106,15 @@ class InScriptError(Exception):
         if self.hint:
             parts.append(f"  Hint: {self.hint}")
 
-        # Call trace (runtime only)
+        # Call trace (runtime only) — v1.7.3: entries are (fn, file, line, src) 4-tuples
         if self.call_trace:
             parts.append("\nCall stack (most recent last):")
-            for fn, file, ln in self.call_trace:
+            for entry in self.call_trace:
+                fn, file, ln = entry[0], entry[1], entry[2]
+                src = entry[3] if len(entry) > 3 else ""
                 parts.append(f"  File \"{file}\", line {ln}, in {fn}")
+                if src:
+                    parts.append(f"    {src}")
 
         # Docs link
         parts.append(f"  See: {DOCS_BASE}/{code}")
@@ -222,11 +229,12 @@ class InScriptWarning:
 # ─────────────────────────────────────────────────────────────────────────────
 
 class CallFrame:
-    __slots__ = ("fn_name", "file", "line")
-    def __init__(self, fn_name: str, file: str, line: int):
-        self.fn_name = fn_name
-        self.file    = file
-        self.line    = line
+    __slots__ = ("fn_name", "file", "line", "source_line")
+    def __init__(self, fn_name: str, file: str, line: int, source_line: str = ""):
+        self.fn_name     = fn_name
+        self.file        = file
+        self.line        = line
+        self.source_line = source_line   # v1.7.3: source snippet at this frame
 
     def as_tuple(self) -> Tuple[str, str, int]:
         return (self.fn_name, self.file, self.line)
@@ -239,40 +247,54 @@ class InScriptCallStack:
     """
     MAX_FRAMES = 200
 
-    def __init__(self, filename: str = "<script>"):
+    def __init__(self, filename: str = "<script>", src_lines: list = None):
         self._frames: List[CallFrame] = []
         self._file   = filename
+        self._src    = src_lines or []   # v1.7.3: source lines for per-frame snippets
+
+    def _lookup_src(self, line: int) -> str:
+        """Return stripped source line, or '' if unavailable."""
+        if self._src and 0 < line <= len(self._src):
+            return self._src[line - 1].strip()
+        return ""
 
     def push(self, fn_name: str, line: int):
         if len(self._frames) < self.MAX_FRAMES:
-            self._frames.append(CallFrame(fn_name, self._file, line))
+            self._frames.append(
+                CallFrame(fn_name, self._file, line, self._lookup_src(line))
+            )
 
     def pop(self):
         if self._frames:
             self._frames.pop()
 
     def snapshot(self) -> List[Tuple[str, str, int]]:
-        """Return a copy of current frames as list of (fn, file, line) tuples."""
-        return [f.as_tuple() for f in self._frames]
+        """Return a copy of current frames as (fn, file, line, source_line) 4-tuples.
+        Backwards-compatible: consumers that only unpack 3 elements still work."""
+        return [(f.fn_name, f.file, f.line, f.source_line) for f in self._frames]
 
     def update_top_line(self, line: int):
-        """Keep top frame's line number current as execution proceeds."""
-        if self._frames:
-            self._frames[-1].line = line
+        """v1.7.3: Keep top frame's line number AND source snippet current during execution."""
+        if self._frames and line:
+            f             = self._frames[-1]
+            f.line        = line
+            f.source_line = self._lookup_src(line)
 
     def format(self) -> str:
         if not self._frames:
             return ""
-        lines = ["Call stack (most recent last):"]
-        shown = self._frames
+        lines     = ["Call stack (most recent last):"]
+        shown     = self._frames
         truncated = 0
         if len(shown) > 20:
             truncated = len(shown) - 20
-            shown = shown[-20:]
+            shown     = shown[-20:]
         if truncated:
             lines.append(f"  ... {truncated} earlier frame(s) ...")
         for f in shown:
             lines.append(f'  File "{f.file}", line {f.line}, in {f.fn_name}')
+            if f.source_line:                        # v1.7.3: source snippet per frame
+                lines.append(f"    {f.source_line}")
         return "\n".join(lines)
 
 

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "1.6.0"
+VERSION = "1.7.3"
 LANG    = "InScript"
 PACKAGES_DIR = os.path.join(os.path.expanduser("~"), ".inscript", "packages")
 REGISTRY_URL = "https://raw.githubusercontent.com/authorss81/inscript-packages/main/registry.json"
@@ -245,6 +245,51 @@ def _check_all_files(directory: str, strict: bool = False) -> int:
     return 1 if errors else 0
 
 
+def _migrate_files(path: str) -> int:
+    """v1.7.4: Auto-migrate deprecated InScript syntax in-place."""
+    import re, os
+    target = os.path.abspath(path)
+    files = []
+    if os.path.isfile(target):
+        files = [target]
+    elif os.path.isdir(target):
+        files = list(_find_ins_files(target))
+    else:
+        print(f"[InScript migrate] Not found: '{path}'", file=sys.stderr)
+        return 1
+
+    changed = errors = 0
+    for fpath in files:
+        try:
+            with open(fpath, encoding="utf-8") as f:
+                original = f.read()
+            src = original
+            # null → nil
+            src = re.sub(r'\bnull\b', 'nil', src)
+            # x div y → x // y  (only bare `div` between expressions)
+            src = re.sub(r'\bdiv\b', '//', src)
+            # bare [] type annotation → array  (e.g. `: []` → `: array`)
+            src = re.sub(r':\s*\[\]', ': array', src)
+            if src != original:
+                with open(fpath, "w", encoding="utf-8") as f:
+                    f.write(src)
+                print(f"  MIGRATED  {fpath}")
+                changed += 1
+            else:
+                print(f"  OK        {fpath}")
+        except Exception as e:
+            errors += 1
+            print(f"  ERR       {fpath}: {e}", file=sys.stderr)
+
+    sep = "-" * 50
+    print(f"\n{sep}")
+    print(f"  Migrated {changed} file{'s' if changed != 1 else ''}, "
+          f"{len(files)-changed-errors} already clean, "
+          f"{errors} error{'s' if errors != 1 else ''}")
+    print(sep)
+    return 1 if errors else 0
+
+
 def _fmt_all_files(directory: str) -> int:
     """v1.6.0: Format all .ins files in directory in-place. Returns exit code."""
     files = list(_find_ins_files(directory))
@@ -568,6 +613,8 @@ Examples:
     parser.add_argument("--check",  action="store_true", help="Type-check only, don't run")
     parser.add_argument("--check-all", metavar="DIR",
                         help="v1.6.0: Check all .ins files in DIR recursively, exit 1 if any errors")
+    parser.add_argument("--migrate", metavar="DIR_OR_FILE",
+                        help="v1.7.4: Auto-migrate deprecated syntax (null→nil, div→//)")
     parser.add_argument("--strict", action="store_true",
                         help="v1.6.0: Strict mode — all warnings become errors, no implicit any")
     parser.add_argument("--tokens", action="store_true", help="Print lexer token stream")
@@ -721,6 +768,8 @@ Examples:
                                 strict=getattr(args, 'strict', False))
     if getattr(args, 'fmt_all', None):
         return _fmt_all_files(args.fmt_all)
+    if getattr(args, 'migrate', None):
+        return _migrate_files(args.migrate)
 
     if not args.file:
         parser.print_help()

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/inscript_lang.egg-info/PKG-INFO

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

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/interpreter.py

@@ -39,7 +39,7 @@ class Interpreter(Visitor):
         self._env     = self._globals
         self._call_depth = 0
         self._MAX_CALL_DEPTH = 500
-        self._call_stack = InScriptCallStack(filename)   # Phase 3.4
+        self._call_stack = InScriptCallStack(filename, src_lines=source_lines)   # v1.7.3
 
         # v1.3.0: dispatch cache — build once, avoids getattr on every node visit
         self._dispatch: dict = {}
@@ -75,6 +75,22 @@ class Interpreter(Visitor):
 
     # ── entry point ───────────────────────────────────────────────────────────
 
+    # v1.7.3: Override Visitor.visit() to track current execution line in the
+    # top call-stack frame.  This makes stack-trace line numbers point to the
+    # exact statement that was executing when an error occurred, rather than
+    # the call-site where the function was entered.
+    def visit(self, node) -> Any:
+        line = getattr(node, 'line', 0)
+        if line:
+            self._call_stack.update_top_line(line)
+        cls = type(node)
+        try:
+            return self._dispatch[cls](node)
+        except KeyError:
+            method = getattr(self, f"visit_{cls.__name__}", self.generic_visit)
+            self._dispatch[cls] = method
+            return method(node)
+
     def run(self, program: Program) -> Any:
         """Execute a full program."""
         return self.visit(program)
@@ -1288,16 +1304,18 @@ class Interpreter(Visitor):
 
     def visit_ThrowStmt(self, node) -> Any:
         val = self.visit(node.value)
-        # BUG-11 fix: tag error with the InScript type name of the thrown value
-        # so that `catch e: string` can match when `throw "hello"` is used
         if isinstance(val, str):     etype = 'string'
         elif isinstance(val, bool):  etype = 'bool'
         elif isinstance(val, int):   etype = 'int'
         elif isinstance(val, float): etype = 'float'
         else:                         etype = 'Error'
-        err = InScriptRuntimeError(str(val), node.line)
-        err.error_type = etype
-        err.thrown_value = val
+        # v1.7.3: capture full call stack at throw time
+        trace = self._call_stack.snapshot()
+        err = InScriptRuntimeError(str(val), node.line,
+                                   source_line=self._src_line(node.line),
+                                   call_trace=trace)
+        err.error_type    = etype
+        err.thrown_value  = val
         raise err
 
     def visit_TryExpr(self, node) -> Any:
@@ -1487,12 +1505,15 @@ class Interpreter(Visitor):
     def visit_FloatLiteralExpr(self, n): return n.value
     def visit_StringLiteralExpr(self,n): return n.value
     def visit_BoolLiteralExpr(self,  n): return n.value
-    def visit_NullLiteralExpr(self,  n):
-        # DESIGN-06: 'null' is a deprecated alias for 'nil' — warn once per session
-        if not getattr(self, '_null_warned', False):
-            import sys
-            print("\033[33m[InScript] Warning: 'null' is deprecated — use 'nil' instead\033[0m", file=sys.stderr)
-            self._null_warned = True
+    def visit_NullLiteralExpr(self, n):
+        # v1.7.4: 'null' keyword is a hard error; 'nil' is correct
+        if getattr(n, '_is_null_keyword', False):
+            raise InScriptRuntimeError(
+                "'null' was removed in v1.7.4 — use 'nil' instead. "
+                "Run: inscript migrate <file> to auto-fix.",
+                getattr(n, 'line', 0),
+                code="E0055",
+            )
         return None
 
     def visit_IdentExpr(self, node: IdentExpr) -> Any:
@@ -3292,6 +3313,46 @@ def _maybe_copy_value(val):
     return val
 
 
+def _format_float(val: float) -> str:
+    """v1.7.1: Clean float display.
+    0.30000000000000004 → '0.3',  1.0 → '1.0',
+    1/3 → '0.3333333333333333',  sqrt(2) → '1.4142135623730951'
+    """
+    if math.isinf(val): return "Infinity" if val > 0 else "-Infinity"
+    if math.isnan(val): return "NaN"
+    if val == int(val) and abs(val) < 1e15:
+        return f"{int(val)}.0"
+
+    # Get the definitive repr (always round-trips correctly)
+    s_repr = repr(val)
+
+    # Try 15 sig figs — may produce a shorter/cleaner string for float-noise values
+    s15 = f"{val:.15g}"
+    try:
+        v15 = float(s15)
+        # Only use 15g result if it's strictly shorter than repr AND round-trips close enough
+        # "Shorter" means fewer significant digits → it genuinely simplified the value
+        denom = abs(val) if val != 0 else 1.0
+        rel_err = abs(v15 - val) / denom
+        if rel_err < 2e-15 and len(s15.rstrip('0').rstrip('.')) <= len(s_repr) - 2:
+            s = s15
+            if '.' in s and 'e' not in s and 'E' not in s:
+                s = s.rstrip('0')
+                if s.endswith('.'):
+                    s += '0'
+            return s
+    except Exception:
+        pass
+
+    # Use repr — strip redundant trailing zeros but keep all significant digits
+    s = s_repr
+    if '.' in s and 'e' not in s and 'E' not in s:
+        s = s.rstrip('0')
+        if s.endswith('.'):
+            s += '0'
+    return s
+
+
 def _inscript_str(val) -> str:
     if val is None:  return "nil"
     if val is True:  return "true"
@@ -3299,11 +3360,7 @@ def _inscript_str(val) -> str:
     if isinstance(val, list):
         return "[" + ", ".join(_inscript_repr(v) for v in val) + "]"
     if isinstance(val, float):
-        if math.isinf(val): return "Infinity" if val > 0 else "-Infinity"
-        if math.isnan(val): return "NaN"
-        if val == int(val):
-            return f"{int(val)}.0"
-        return str(val)
+        return _format_float(val)
     if isinstance(val, str):
         return val  # bare string — no quotes when printing top-level
     # InScript struct instance — show data fields only, no methods

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/lexer.py

@@ -15,7 +15,8 @@ class TT(Enum):
     FLOAT       = auto()
     STRING      = auto()
     BOOL        = auto()
-    NULL        = auto()
+    NULL        = auto()   # null (removed — hard error)
+    NIL         = auto()   # nil  (the correct nil literal)
 
     # ── Identifiers & Keywords ────────────────────
     IDENT       = auto()
@@ -175,7 +176,7 @@ KEYWORDS: dict = {
     "true":      TT.BOOL,
     "false":     TT.BOOL,
     "null":      TT.NULL,
-    "nil":       TT.NULL,   # alias for null
+    "nil":       TT.NIL,
     "import":    TT.IMPORT,
     "from":      TT.FROM,
     "as":        TT.AS,
@@ -291,16 +292,26 @@ class Lexer:
         if ch in (" ", "\t", "\r", "\n"):
             return
 
-        # // — floor-division or line comment
-        # Floor division: `10 // 3`, `x // 2`, `(a+b) // c`
-        # Comment:        `let x = 5 // this is a comment`
-        # Key rule: look at what comes AFTER the second /
-        #   - digit or ( → always floor division
-        #   - letter/word → always comment
-        # Phase 1.2: // is now ALWAYS a line comment. Floor division uses 'div' keyword.
+        # // — floor-division operator or line comment
+        # v1.7.1: `//` is now the integer division operator (10 // 3 → 3)
+        # Line comment: `let x = 5   // this is a comment` — space before //
+        # Floor division: `10 // 3`, `x//2`, `(a+b) // c`
+        # Rule: if the character BEFORE // was a digit, ), ], or identifier char → floor div
+        #        otherwise → line comment
         if ch == "/" and self.current == "/":
             self.advance()  # consume second /
-            self._skip_line_comment()
+            # Determine: floor-div or line comment?
+            # Rule: the character IMMEDIATELY before first '/' (no whitespace allowed)
+            # must be digit/identifier/closing bracket to be floor-div.
+            # Any space/tab before the // → line comment.
+            first_slash_pos = self.pos - 2
+            prev = self.source[first_slash_pos - 1] if first_slash_pos > 0 else ''
+            if prev and (prev.isdigit() or prev.isalpha() or prev in ')]}'):
+                # `10//3`, `x//2`, `(a+b)//c` — no space → floor division
+                self._emit(TT.SLASH_SLASH, "//", sl, sc)
+            else:
+                # `10 // 3` with spaces, `5 // comment`, `// standalone` → comment
+                self._skip_line_comment()
             return
         if ch == "/" and self.current == "*":
             self._skip_block_comment(sl, sc); return
@@ -497,7 +508,8 @@ class Lexer:
         text = "".join(chars)
         tt   = KEYWORDS.get(text, TT.IDENT)
         if tt == TT.BOOL:   value = (text == "true")
-        elif tt == TT.NULL: value = None
+        elif tt == TT.NIL:  value = None   # nil literal → Python None
+        elif tt == TT.NULL: value = None   # null (removed keyword — still lex it so error can fire)
         else:               value = text
         self._emit(tt, value, sl, sc)
 
@@ -522,8 +534,8 @@ class Lexer:
             elif self.match("="): emit(TT.STAR_EQ,  "*=")
             else:               emit(TT.STAR,         "*")
         elif ch == "/":
-            if self.match("="): emit(TT.SLASH_EQ,  "/=")
-            else:               emit(TT.SLASH,       "/")
+            if self.match("="):   emit(TT.SLASH_EQ,    "/=")
+            else:                 emit(TT.SLASH,         "/")
         elif ch == "%":
             if self.match("="): emit(TT.PERCENT_EQ, "%=")
             else:               emit(TT.PERCENT,     "%")

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/parser.py

@@ -444,6 +444,9 @@ class Parser:
                             TT.STRING_TYPE, TT.VOID_TYPE, TT.IDENT):
                 name = tok.value
                 self.advance()
+            elif tok.type == TT.NIL:   # v1.7.2: nil as type annotation
+                name = "nil"
+                self.advance()
             else:
                 self._error(f"Expected type name, got '{tok.value}'")
             ann = TypeAnnotation(name=name, line=line, col=col)
@@ -885,8 +888,10 @@ class Parser:
         # e.g.  items: []   or  count: 0   or  value: nil
         type_ann = None
         _type_starts = (TT.IDENT, TT.INT_TYPE, TT.FLOAT_TYPE, TT.BOOL_TYPE,
-                        TT.STRING_TYPE, TT.VOID_TYPE, TT.LBRACE, TT.LPAREN)
+                        TT.STRING_TYPE, TT.VOID_TYPE, TT.LBRACE, TT.LPAREN,
+                        TT.NIL)   # v1.7.2: nil is a valid type (nullable/any)
         # Tokens that unambiguously start a literal default (not a type name)
+        # Note: TT.NIL removed — could be type OR default; handled by _type_starts
         _default_starts = (TT.NULL, TT.BOOL, TT.INT, TT.FLOAT, TT.STRING, TT.MINUS)
 
         if self.check(TT.LBRACKET):
@@ -1623,7 +1628,7 @@ class Parser:
                 attr_tok = self.current
                 # Accept any identifier OR keyword as attribute name (e.g. regex.match, uuid.nil)
                 _KEYWORD_TYPES = {
-                    TT.NULL, TT.MATCH, TT.IN, TT.FOR, TT.IF, TT.ELSE, TT.WHILE,
+                    TT.NIL, TT.NULL, TT.MATCH, TT.IN, TT.FOR, TT.IF, TT.ELSE, TT.WHILE,
                     TT.RETURN, TT.BREAK, TT.CONTINUE, TT.LET, TT.CONST, TT.FN,
                     TT.STRUCT, TT.ENUM, TT.IMPORT, TT.EXPORT, TT.FROM, TT.ASYNC,
                     TT.AWAIT, TT.ABSTRACT, TT.SELECT, TT.CASE, TT.TRY, TT.CATCH,
@@ -1634,7 +1639,7 @@ class Parser:
                 }
                 if attr_tok.type == TT.IDENT or attr_tok.type in _KEYWORD_TYPES:
                     # For NULL token use "nil"; for BOOL use the literal text ("true"/"false")
-                    if attr_tok.type == TT.NULL:
+                    if attr_tok.type in (TT.NIL, TT.NULL):
                         attr = "nil"
                     elif attr_tok.type == TT.BOOL:
                         attr = "true" if attr_tok.value else "false"
@@ -1694,7 +1699,7 @@ class Parser:
             # Propagate ? is followed by newline, }, ), ,, ;, EOF
             elif self.check(TT.QUESTION):
                 _EXPR_START = {
-                    TT.STRING, TT.INT, TT.FLOAT, TT.BOOL, TT.NULL,
+                    TT.STRING, TT.INT, TT.FLOAT, TT.BOOL, TT.NIL, TT.NULL,
                     TT.IDENT, TT.LPAREN, TT.LBRACKET, TT.LBRACE,
                     TT.BIT_OR, TT.OR, TT.NOT, TT.MINUS, TT.FSTRING,
                     TT.INT_TYPE, TT.FLOAT_TYPE, TT.STRING_TYPE, TT.BOOL_TYPE,
@@ -1735,7 +1740,7 @@ class Parser:
             _CHECK_TYPES = {
                 TT.INT_TYPE: "int", TT.FLOAT_TYPE: "float",
                 TT.STRING_TYPE: "string", TT.BOOL_TYPE: "bool",
-                TT.VOID_TYPE: "void", TT.NULL: "nil",
+                TT.VOID_TYPE: "void", TT.NULL: "nil", TT.NIL: "nil",
                 TT.IDENT: None,
             }
             if check_tok.type in _CHECK_TYPES:
@@ -1813,10 +1818,16 @@ class Parser:
             self.advance()
             return BoolLiteralExpr(value=tok.value, line=line, col=col)
 
-        # Null
-        if tok.type == TT.NULL:
+        # nil / null
+        if tok.type == TT.NIL:
             self.advance()
             return NullLiteralExpr(line=line, col=col)
+        if tok.type == TT.NULL:
+            self.advance()
+            # Keep the node but tag it as the removed 'null' keyword
+            node = NullLiteralExpr(line=line, col=col)
+            node._is_null_keyword = True   # interpreter will hard-error on this
+            return node
 
         # Grouped expression: (expr)  OR  Tuple: (expr, expr, ...)
         if tok.type == TT.LPAREN:

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/pyproject.toml

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

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/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 = "1.6.0"
+VERSION = "1.7.3"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):
@@ -434,6 +434,9 @@ class EnhancedREPL:
         self._history: List[str] = []
         self._session: List[str] = []
         self._last_src: str = ""
+        # v1.7.4: mark the root env as REPL-mode so `let` re-declarations
+        # silently re-bind instead of erroring ("let x=1" then "let x=2" works)
+        self._interp._env._repl_mode = True
         self._setup_readline()
 
     def _setup_readline(self):
@@ -457,6 +460,13 @@ class EnhancedREPL:
         from parser import Parser
         from errors import InScriptError
         t0 = time.perf_counter()
+
+        # v1.7.4: snapshot the top-level env so a runtime error can't corrupt
+        # previously-defined globals.  On error we restore the snapshot, which
+        # means any partial defines from the failed block are rolled back —
+        # already-defined names from prior REPL lines are always preserved.
+        env_snapshot = dict(self._interp._env._store)
+
         try:
             tokens  = Lexer(source).tokenize()
             program = Parser(tokens).parse()
@@ -474,8 +484,11 @@ class EnhancedREPL:
                 result = self._interp.run(program)
             return result, None, (time.perf_counter() - t0) * 1000
         except InScriptError as e:
+            # v1.7.4: restore globals so surviving names are untouched
+            self._interp._env._store = env_snapshot
             return None, _format_error(str(e), source), (time.perf_counter() - t0) * 1000
         except Exception as e:
+            self._interp._env._store = env_snapshot
             import traceback as _tb
             return None, f"Internal error: {e}\n{_tb.format_exc()}", (time.perf_counter() - t0) * 1000
 

{inscript_lang-1.6.0 → inscript_lang-1.7.3}/setup.py

@@ -11,7 +11,7 @@ from setuptools import setup, find_packages
 
 setup(
     name             = "inscript-lang",
-    version          = "1.6.0",
+    version          = "1.7.2",
     author           = "Shreyasi Sarkar",
     description      = "InScript — a game-focused scripting language for 2D games",
     long_description = open("README.md", encoding="utf-8").read(),