inscript-lang 2.11.0__tar.gz → 2.12.0__tar.gz

{inscript_lang-2.11.0 → inscript_lang-2.12.0}/PKG-INFO

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

{inscript_lang-2.11.0 → inscript_lang-2.12.0}/errors.py

@@ -85,6 +85,24 @@ class InScriptError(Exception):
         self.code = code or ERROR_CODES.get(cls_name, "E0000")
         super().__init__(self._format())
 
+    def to_dict(self) -> dict:
+        """v2.12.0: Structured dict for --json-errors / Studio error panel."""
+        return {
+            "type":        "error",
+            "code":        self.code,
+            "class":       type(self).__name__,
+            "message":     self.message,
+            "line":        self.line,
+            "col":         self.col,
+            "source_line": self.source_line,
+            "hint":        self.hint,
+            "call_trace":  self.call_trace,
+        }
+
+    def to_json(self) -> str:
+        import json as _j
+        return _j.dumps(self.to_dict(), separators=(",", ":"))
+
     def _format(self) -> str:
         code   = self.code
         cls    = type(self).__name__

{inscript_lang-2.11.0 → inscript_lang-2.12.0}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "2.11.0"
+VERSION = "2.12.0"
 
 MANIFEST_FILENAME = "inscript.toml"
 LOCK_FILENAME     = "inscript.lock"
@@ -2385,21 +2385,34 @@ def run_source(source: str, filename: str = "<stdin>",
                no_warn_unused: bool = False,
                warn_as_error: bool = False,
                strict: bool = False,
-               profile: bool = False) -> int:
+               profile: bool = False,
+               json_errors: bool = False) -> int:
     """Lex, parse, analyze, and interpret InScript source code."""
+
+    def _emit_error(e):
+        """v2.12.0: emit as JSON or plain text depending on flag."""
+        if json_errors:
+            from inscript_studio_api import error_stream
+            from errors import InScriptError as _ISE
+            if isinstance(e, _ISE):
+                error_stream([e])
+            else:
+                error_stream([{"type": "error", "code": "E0000",
+                               "class": type(e).__name__, "message": str(e),
+                               "line": 0, "col": 0}])
+        else:
+            print(e, file=sys.stderr)
     # ── 1. Lex ────────────────────────────────────────────────────────────
     try:
         tokens = tokenize(source, filename)
     except LexerError as e:
-        print(e, file=sys.stderr)
-        return 1
+        _emit_error(e); return 1
 
     # ── 2. Parse ──────────────────────────────────────────────────────────
     try:
         program = parse(source, filename)
     except ParseError as e:
-        print(e, file=sys.stderr)
-        return 1
+        _emit_error(e); return 1
 
     # ── 3. Analyze (optional) — Phase 3: multi-error + warnings ──────────
     if type_check:
@@ -2442,7 +2455,7 @@ def run_source(source: str, filename: str = "<stdin>",
             interp.run(program)
         return 0
     except InScriptError as e:
-        print(e, file=sys.stderr)
+        _emit_error(e)
         return 1
     except KeyboardInterrupt:
         print("\n[InScript] Interrupted.", file=sys.stderr)
@@ -2728,6 +2741,17 @@ Examples:
                         help="v2.11.0: Project root for --build (default: current dir)")
     parser.add_argument("--new", metavar="NAME",
                         help="v2.11.0: Scaffold a new InScript project: inscript --new mygame")
+    # v2.12.0: studio readiness
+    parser.add_argument("--json-errors", action="store_true",
+                        help="v2.12.0: Output errors as newline-delimited JSON for IDE panels")
+    parser.add_argument("--inspect", metavar="DIR", nargs="?", const=".",
+                        help="v2.12.0: Project introspection → JSON (scenes, nodes, assets, fns)")
+    parser.add_argument("--check-v3", action="store_true",
+                        help="v2.12.0: Run v3.0.0 readiness gates; exits 0 if all pass")
+    parser.add_argument("--studio-bridge", action="store_true",
+                        help="v2.12.0: Start Electron bridge JSON-RPC server")
+    parser.add_argument("--bridge-port", type=int, default=8765,
+                        help="v2.12.0: Port for --studio-bridge (default: 8765)")
     parser.add_argument("--lsp", action="store_true",
                         help="Start the Language Server (requires: pip install pygls)")
     parser.add_argument("--game", action="store_true",
@@ -3012,6 +3036,37 @@ Examples:
         except Exception as _bld:
             print(f"[build] {_bld}", file=sys.stderr); return 1
 
+    # ── v2.12.0 studio readiness ───────────────────────────────────────────
+    if getattr(args, 'check_v3', False):
+        from studio_readiness import run_all_gates
+        base = getattr(args, 'project_dir', '.') or '.'
+        _, all_passed = run_all_gates(base_dir=base)
+        return 0 if all_passed else 1
+
+    if getattr(args, 'inspect', None) is not None:
+        try:
+            from inscript_studio_api import project_inspect
+            import json as _j
+            data = project_inspect(args.inspect)
+            print(_j.dumps(data, indent=2))
+        except Exception as _ie:
+            print(f"[inspect] {_ie}", file=sys.stderr); return 1
+        return 0
+
+    if getattr(args, 'studio_bridge', False):
+        from studio_bridge import StudioBridge
+        import time as _time
+        port   = getattr(args, 'bridge_port', 8765)
+        bridge = StudioBridge(port=port)
+        bridge.start()
+        print(f"[studio-bridge] Listening on {bridge.url}")
+        print(f"[studio-bridge] Ctrl+C to stop")
+        try:
+            while True: _time.sleep(1)
+        except KeyboardInterrupt:
+            bridge.stop()
+        return 0
+
     # v1.9.1: --no-typecheck is deprecated — emit a warning and honour it
     if getattr(args, 'no_typecheck', False):
         print(
@@ -3097,7 +3152,8 @@ Examples:
     return run_source(_source, filename=args.file, type_check=type_check,
                       no_warn=no_warn, no_warn_unused=no_warn_unused,
                       warn_as_error=warn_as_error, strict=strict,
-                      profile=profile)
+                      profile=profile,
+                      json_errors=getattr(args, 'json_errors', False))
 
 
 # ─────────────────────────────────────────────────────────────────────────────

{inscript_lang-2.11.0 → inscript_lang-2.12.0}/inscript_lang.egg-info/PKG-INFO

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

{inscript_lang-2.11.0 → inscript_lang-2.12.0}/inscript_lang.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ hot_reload.py
 inscript.py
 inscript_dap.py
 inscript_fmt.py
+inscript_studio_api.py
 inscript_test.py
 interpreter.py
 lexer.py
@@ -24,6 +25,8 @@ stdlib_extended.py
 stdlib_extended_2.py
 stdlib_game.py
 stdlib_values.py
+studio_bridge.py
+studio_readiness.py
 vm.py
 inscript_lang.egg-info/PKG-INFO
 inscript_lang.egg-info/SOURCES.txt

{inscript_lang-2.11.0 → inscript_lang-2.12.0}/inscript_lang.egg-info/top_level.txt

@@ -8,6 +8,7 @@ hot_reload
 inscript
 inscript_dap
 inscript_fmt
+inscript_studio_api
 inscript_test
 interpreter
 lexer
@@ -21,4 +22,6 @@ stdlib_extended
 stdlib_extended_2
 stdlib_game
 stdlib_values
+studio_bridge
+studio_readiness
 vm

inscript_lang-2.12.0/inscript_studio_api.py

@@ -0,0 +1,295 @@
+# -*- coding: utf-8 -*-
+"""
+inscript_studio_api.py — InScript v2.12.0  Studio Plugin API
+================================================================
+Stable extension points that InScript Studio (Electron) and third-party
+plugins use to integrate with the runtime.
+
+StudioPlugin   — base class for plugins; override hook methods
+StudioAPI      — registry; emit events to all registered plugins
+project_inspect — static analysis → JSON scene/node/fn/asset list
+error_stream    — format errors as newline-delimited JSON for the IDE panel
+"""
+
+from __future__ import annotations
+import os, re, json
+from typing import Any, Dict, List, Optional
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Plugin base class
+# ─────────────────────────────────────────────────────────────────────────────
+
+class StudioPlugin:
+    """
+    Base class for Studio plugins.  Override any hook you care about.
+
+    Plugins are registered with the global StudioAPI singleton:
+        from inscript_studio_api import get_api
+        get_api().register(MyPlugin())
+    """
+    name: str = "unnamed_plugin"
+
+    def on_scene_save(self, scene_path: str, tree) -> None:
+        """Called when a .inscene file is saved from the editor."""
+
+    def on_asset_import(self, handle) -> None:
+        """Called when an AssetHandle is registered in the AssetRegistry."""
+
+    def on_error(self, error: dict) -> None:
+        """Called when the interpreter raises an InScriptError.
+        error is a dict matching InScriptError.to_dict()."""
+
+    def on_breakpoint(self, file: str, line: int, env: dict) -> None:
+        """Called when a breakpoint is hit (DAP integration)."""
+
+    def on_reload(self, result) -> None:
+        """Called after every successful hot reload."""
+
+    def on_build(self, target: str, output_dir: str, success: bool) -> None:
+        """Called after inscript build completes."""
+
+    def __repr__(self):
+        return f"<StudioPlugin {self.name}>"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# StudioAPI registry
+# ─────────────────────────────────────────────────────────────────────────────
+
+class StudioAPI:
+    """
+    Central registry for Studio plugins.  Emits lifecycle events to all
+    registered plugins.  Singleton — use get_api() rather than instantiating.
+    """
+    def __init__(self):
+        self._plugins: List[StudioPlugin] = []
+
+    def register(self, plugin: StudioPlugin) -> "StudioAPI":
+        if plugin not in self._plugins:
+            self._plugins.append(plugin)
+        return self
+
+    def unregister(self, plugin: StudioPlugin) -> bool:
+        if plugin in self._plugins:
+            self._plugins.remove(plugin)
+            return True
+        return False
+
+    def plugin_count(self) -> int:
+        return len(self._plugins)
+
+    def emit(self, event: str, *args, **kwargs) -> List[Any]:
+        """
+        Emit an event to all registered plugins.
+        Returns list of return values (Nones filtered out).
+        """
+        results = []
+        for plugin in list(self._plugins):
+            handler = getattr(plugin, event, None)
+            if handler is None:
+                continue
+            try:
+                rv = handler(*args, **kwargs)
+                if rv is not None:
+                    results.append(rv)
+            except Exception as e:
+                print(f"[StudioAPI] Plugin '{plugin.name}' error in {event}: {e}")
+        return results
+
+    # Convenience emitters matching StudioPlugin hooks
+    def emit_scene_save(self, scene_path: str, tree) -> None:
+        self.emit("on_scene_save", scene_path, tree)
+
+    def emit_asset_import(self, handle) -> None:
+        self.emit("on_asset_import", handle)
+
+    def emit_error(self, error: dict) -> None:
+        self.emit("on_error", error)
+
+    def emit_breakpoint(self, file: str, line: int, env: dict) -> None:
+        self.emit("on_breakpoint", file, line, env)
+
+    def emit_reload(self, result) -> None:
+        self.emit("on_reload", result)
+
+    def emit_build(self, target: str, output_dir: str, success: bool) -> None:
+        self.emit("on_build", target, output_dir, success)
+
+    def __repr__(self):
+        return f"<StudioAPI plugins={len(self._plugins)}>"
+
+
+# Module-level singleton
+_GLOBAL_API = StudioAPI()
+
+def get_api() -> StudioAPI:
+    return _GLOBAL_API
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Project introspection — static analysis without running the interpreter
+# ─────────────────────────────────────────────────────────────────────────────
+
+# Patterns for extracting declarations from .ins source (fast, no full parse)
+_RE_NODE     = re.compile(r'^\s*node\s+(\w+)\s*\{', re.MULTILINE)
+_RE_SCENE    = re.compile(r'^\s*scene\s+(\w+)\s*\{', re.MULTILINE)
+_RE_STRUCT   = re.compile(r'^\s*struct\s+(\w+)\s*\{', re.MULTILINE)
+_RE_FN       = re.compile(r'^\s*(?:export\s+)?fn\s+(\w+)\s*\(', re.MULTILINE)
+_RE_TEXTURE  = re.compile(r'@texture\s*\(\s*["\']([^"\']+)["\']', re.MULTILINE)
+_RE_SOUND    = re.compile(r'@sound\s*\(\s*["\']([^"\']+)["\']', re.MULTILINE)
+_RE_TILEMAP  = re.compile(r'@tilemap\s*\(\s*["\']([^"\']+)["\']', re.MULTILINE)
+_RE_FONT     = re.compile(r'@font\s*\(\s*["\']([^"\']+)["\']', re.MULTILINE)
+_RE_IMPORT   = re.compile(r'^\s*import\s+["\']([^"\']+)["\']', re.MULTILINE)
+
+
+def _scan_ins_file(file_path: str) -> dict:
+    """
+    Scan a single .ins file and return a summary dict:
+      {file, nodes, scenes, structs, functions, assets, imports}
+    """
+    try:
+        with open(file_path, encoding="utf-8") as f:
+            src = f.read()
+    except OSError:
+        return {}
+
+    rel = file_path  # caller normalises
+
+    assets = []
+    for kind, pat in (("texture", _RE_TEXTURE), ("sound", _RE_SOUND),
+                      ("tilemap", _RE_TILEMAP), ("font", _RE_FONT)):
+        for m in pat.finditer(src):
+            assets.append({"type": kind, "path": m.group(1)})
+
+    return {
+        "file":      rel,
+        "nodes":     [m.group(1) for m in _RE_NODE.finditer(src)],
+        "scenes":    [m.group(1) for m in _RE_SCENE.finditer(src)],
+        "structs":   [m.group(1) for m in _RE_STRUCT.finditer(src)],
+        "functions": [m.group(1) for m in _RE_FN.finditer(src)],
+        "assets":    assets,
+        "imports":   [m.group(1) for m in _RE_IMPORT.finditer(src)],
+    }
+
+
+def _scan_inscene_file(file_path: str) -> Optional[dict]:
+    """Read a .inscene file and return {file, scene_name, root, nodes}."""
+    try:
+        with open(file_path, encoding="utf-8") as f:
+            content = f.read()
+    except OSError:
+        return None
+
+    name_m = re.search(r'^name\s*=\s*"([^"]+)"', content, re.MULTILINE)
+    root_m = re.search(r'^root\s*=\s*"([^"]+)"', content, re.MULTILINE)
+    nodes  = re.findall(r'^type\s*=\s*"([^"]+)"', content, re.MULTILINE)
+
+    return {
+        "file":       file_path,
+        "scene_name": name_m.group(1) if name_m else "",
+        "root":       root_m.group(1) if root_m else "",
+        "nodes":      nodes,
+    }
+
+
+def project_inspect(project_dir: str = ".") -> dict:
+    """
+    Statically analyse a project directory and return a JSON-serialisable
+    summary of all declarations.  Used by the Studio scene panel, node
+    inspector, and asset browser.
+
+    Returns:
+      {
+        "project_dir": str,
+        "version":     str,            # inscript.VERSION
+        "sources":     [...],          # per-file scan results
+        "scenes":      [...],          # merged list of scene names
+        "nodes":       [...],          # merged list of node names
+        "structs":     [...],
+        "functions":   [...],
+        "assets":      [...],
+        "scene_files": [...],          # .inscene file summaries
+        "imports":     [...],
+      }
+    """
+    from inscript import VERSION
+
+    project_dir = os.path.abspath(project_dir)
+    sources = []
+    scene_files = []
+
+    all_scenes    = []
+    all_nodes     = []
+    all_structs   = []
+    all_functions = []
+    all_assets    = []
+    all_imports   = set()
+
+    # Walk the project for .ins and .inscene files
+    for root, dirs, files in os.walk(project_dir):
+        # Skip build output and hidden dirs
+        dirs[:] = [d for d in dirs
+                   if d not in ("build", "__pycache__", "inscript_runtime")
+                   and not d.startswith(".")]
+        for fn in sorted(files):
+            full = os.path.join(root, fn)
+            rel  = os.path.relpath(full, project_dir)
+            if fn.endswith(".ins"):
+                scan = _scan_ins_file(full)
+                scan["file"] = rel
+                sources.append(scan)
+                all_scenes    += [{"name": n, "file": rel} for n in scan["nodes"]]
+                all_nodes     += [{"name": n, "file": rel} for n in scan["nodes"]]
+                all_structs   += [{"name": n, "file": rel} for n in scan["structs"]]
+                all_functions += [{"name": n, "file": rel} for n in scan["functions"]]
+                all_assets    += [dict(a, file=rel) for a in scan["assets"]]
+                all_imports   |= set(scan["imports"])
+            elif fn.endswith(".inscene"):
+                sf = _scan_inscene_file(full)
+                if sf:
+                    sf["file"] = rel
+                    scene_files.append(sf)
+                    all_scenes.append({"name": sf["scene_name"], "file": rel,
+                                       "root": sf["root"]})
+
+    return {
+        "project_dir": project_dir,
+        "version":     VERSION,
+        "sources":     sources,
+        "scenes":      all_scenes,
+        "nodes":       all_nodes,
+        "structs":     all_structs,
+        "functions":   all_functions,
+        "assets":      all_assets,
+        "scene_files": scene_files,
+        "imports":     sorted(all_imports),
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Error stream — newline-delimited JSON for IDE panels
+# ─────────────────────────────────────────────────────────────────────────────
+
+def error_stream(errors: list, file=None) -> None:
+    """
+    Write errors as newline-delimited JSON to `file` (default: sys.stderr).
+    Each line is a self-contained JSON object.
+
+    Format:
+      {"type":"error","code":"E0042","message":"...","line":5,"col":3}
+      {"type":"error","code":"E0001","message":"...","line":12,"col":1}
+    """
+    import sys as _sys
+    out = file or _sys.stderr
+    for err in errors:
+        if hasattr(err, "to_dict"):
+            d = err.to_dict()
+        elif isinstance(err, dict):
+            d = err
+        else:
+            d = {"type": "error", "code": "E0000",
+                 "class": type(err).__name__, "message": str(err),
+                 "line": 0, "col": 0}
+        out.write(json.dumps(d, separators=(",", ":")) + "\n")
+    out.flush()

{inscript_lang-2.11.0 → inscript_lang-2.12.0}/pyproject.toml

@@ -61,7 +61,8 @@ py-modules = [
     # ── Backends ──────────────────────────────────────────────────────────────
     "pygame_backend",
     # ── v2.7.0+ runtime modules ───────────────────────────────────────────────
-    "scene_tree", "hot_reload", "export_pipeline"
+    "scene_tree", "hot_reload", "export_pipeline",
+    "studio_bridge", "inscript_studio_api", "studio_readiness"
 ]
 
 [tool.setuptools.package-data]

{inscript_lang-2.11.0 → inscript_lang-2.12.0}/setup.py

@@ -56,6 +56,7 @@ setup(
         "pygame_backend",
         # ── v2.7.0+ runtime modules ───────────────────────────────────────────
         "scene_tree", "hot_reload", "export_pipeline",
+        "studio_bridge", "inscript_studio_api", "studio_readiness",
     ],
     package_data     = {"": ["examples/*.ins", "lsp/*.py", "*.md"]},
     install_requires = [],

inscript_lang-2.12.0/studio_bridge.py

@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+"""
+studio_bridge.py — InScript v2.12.0  Electron Bridge
+================================================================
+A lightweight JSON-RPC HTTP server that the InScript Studio Electron
+shell calls to drive the runtime.
+
+Start from CLI:
+  inscript --studio-bridge [--bridge-port 8765]
+
+Or from Python:
+  from studio_bridge import StudioBridge
+  bridge = StudioBridge(port=8765)
+  bridge.start()   # non-blocking daemon thread
+  bridge.stop()
+
+JSON-RPC protocol (HTTP POST to /rpc):
+  Request:  { "method": "run",       "id": 1, "params": {"file": "src/main.ins"} }
+  Response: { "result": "ok",        "id": 1 }
+  Error:    { "error": "...",        "id": 1 }
+
+Methods
+───────
+  run          — execute a .ins file; returns {"status": "ok"|"error", "output": [...]}
+  stop         — stop a running interpreter
+  hot_reload   — trigger hot reload on a file
+  scene_list   — return all scene/node declarations in project
+  inspect      — full project introspection (scenes, nodes, fns, assets)
+  eval         — evaluate an InScript expression in live env
+  ping         — health check; returns {"pong": true}
+  version      — returns {"version": "2.12.0"}
+"""
+
+from __future__ import annotations
+import json, threading, sys, os, io
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Any, Dict, Optional
+
+DEFAULT_PORT = 8765
+
+
+class _RpcHandler(BaseHTTPRequestHandler):
+    """HTTP handler — all requests are POST to /rpc."""
+
+    def log_message(self, fmt, *args):
+        pass  # suppress default access log
+
+    def do_POST(self):
+        if self.path != "/rpc":
+            self._reply(404, {"error": "Not found — POST to /rpc"})
+            return
+        try:
+            length  = int(self.headers.get("Content-Length", 0))
+            body    = self.rfile.read(length)
+            request = json.loads(body)
+        except Exception as e:
+            self._reply(400, {"error": f"Bad JSON: {e}", "id": None})
+            return
+
+        req_id  = request.get("id")
+        method  = request.get("method", "")
+        params  = request.get("params", {})
+
+        try:
+            result = self.server._bridge._dispatch(method, params)
+            self._reply(200, {"result": result, "id": req_id})
+        except Exception as e:
+            self._reply(200, {"error": str(e), "id": req_id})
+
+    def _reply(self, status: int, data: dict):
+        body = json.dumps(data, default=str).encode()
+        self.send_response(status)
+        self.send_header("Content-Type",   "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+        self.wfile.write(body)
+
+
+class StudioBridge:
+    """
+    Lightweight JSON-RPC bridge between the InScript runtime and
+    the Electron Studio shell.
+    """
+    def __init__(self, port: int = DEFAULT_PORT):
+        self._port    = port
+        self._server: Optional[HTTPServer] = None
+        self._thread: Optional[threading.Thread] = None
+        self._interp  = None   # live Interpreter (created on first run)
+        self._lock    = threading.Lock()
+        self._running = False
+
+    # ── lifecycle ──────────────────────────────────────────────────────────────
+
+    def start(self) -> "StudioBridge":
+        """Start the HTTP server in a daemon thread. Non-blocking."""
+        self._server = HTTPServer(("localhost", self._port), _RpcHandler)
+        self._server._bridge = self
+        self._running = True
+        self._thread = threading.Thread(target=self._server.serve_forever, daemon=True)
+        self._thread.start()
+        return self
+
+    def stop(self):
+        """Shut down the HTTP server."""
+        self._running = False
+        if self._server:
+            self._server.shutdown()
+
+    @property
+    def port(self) -> int:
+        return self._port
+
+    @property
+    def url(self) -> str:
+        return f"http://localhost:{self._port}/rpc"
+
+    # ── RPC dispatch ──────────────────────────────────────────────────────────
+
+    def _dispatch(self, method: str, params: dict) -> Any:
+        handlers = {
+            "ping":        self._rpc_ping,
+            "version":     self._rpc_version,
+            "run":         self._rpc_run,
+            "stop":        self._rpc_stop,
+            "hot_reload":  self._rpc_hot_reload,
+            "scene_list":  self._rpc_scene_list,
+            "inspect":     self._rpc_inspect,
+            "eval":        self._rpc_eval,
+        }
+        handler = handlers.get(method)
+        if handler is None:
+            raise ValueError(f"Unknown method '{method}'. Available: {sorted(handlers)}")
+        return handler(params)
+
+    # ── RPC handlers ──────────────────────────────────────────────────────────
+
+    def _rpc_ping(self, _params: dict) -> dict:
+        return {"pong": True, "port": self._port}
+
+    def _rpc_version(self, _params: dict) -> dict:
+        from inscript import VERSION
+        return {"version": VERSION, "bridge": "1.0"}
+
+    def _rpc_run(self, params: dict) -> dict:
+        """Run a .ins file and return captured output + errors."""
+        file_path = params.get("file", "")
+        if not file_path:
+            raise ValueError("'file' parameter required")
+        if not os.path.isfile(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        with open(file_path, encoding="utf-8") as f:
+            source = f.read()
+
+        output_lines: list = []
+        errors: list = []
+
+        # Redirect stdout
+        old_stdout = sys.stdout
+        sys.stdout = io.StringIO()
+
+        try:
+            from interpreter import Interpreter
+            from errors import InScriptError
+            with self._lock:
+                self._interp = Interpreter()
+            self._interp.execute(source)
+            output_lines = sys.stdout.getvalue().splitlines()
+        except Exception as e:
+            from errors import InScriptError
+            if isinstance(e, InScriptError):
+                errors.append(e.to_dict())
+            else:
+                errors.append({"type": "error", "code": "E0000",
+                                "class": type(e).__name__, "message": str(e),
+                                "line": 0, "col": 0})
+            output_lines = sys.stdout.getvalue().splitlines()
+        finally:
+            sys.stdout = old_stdout
+
+        return {
+            "status": "error" if errors else "ok",
+            "output": output_lines,
+            "errors": errors,
+        }
+
+    def _rpc_stop(self, _params: dict) -> dict:
+        with self._lock:
+            self._interp = None
+        return {"stopped": True}
+
+    def _rpc_hot_reload(self, params: dict) -> dict:
+        """Trigger a hot reload on a running file."""
+        file_path = params.get("file", "")
+        if not file_path:
+            raise ValueError("'file' parameter required")
+        with self._lock:
+            if self._interp is None:
+                raise RuntimeError("No running interpreter — call 'run' first")
+            from hot_reload import HotReloader
+            reloader = HotReloader(file_path, self._interp)
+            result   = reloader.tick()
+        return {
+            "changed":    result.changed,
+            "success":    result.success,
+            "patched":    result.patched,
+            "restored":   len(result.restored),
+            "errors":     result.errors,
+            "elapsed_ms": result.elapsed_ms,
+        }
+
+    def _rpc_scene_list(self, params: dict) -> dict:
+        """Return all scene and node declarations in a project directory."""
+        project_dir = params.get("dir", ".")
+        from inscript_studio_api import project_inspect
+        data = project_inspect(project_dir)
+        return {"scenes": data["scenes"], "nodes": data["nodes"]}
+
+    def _rpc_inspect(self, params: dict) -> dict:
+        """Full project introspection."""
+        project_dir = params.get("dir", ".")
+        from inscript_studio_api import project_inspect
+        return project_inspect(project_dir)
+
+    def _rpc_eval(self, params: dict) -> dict:
+        """Evaluate an InScript expression in the live interpreter environment."""
+        expr = params.get("expr", "")
+        if not expr:
+            raise ValueError("'expr' parameter required")
+        with self._lock:
+            if self._interp is None:
+                raise RuntimeError("No running interpreter — call 'run' first")
+            result = self._interp.execute(expr)
+        return {"result": result, "type": type(result).__name__}
+
+    def __repr__(self):
+        status = "running" if self._running else "stopped"
+        return f"<StudioBridge port={self._port} {status}>"

inscript_lang-2.12.0/studio_readiness.py

@@ -0,0 +1,408 @@
+# -*- coding: utf-8 -*-
+"""
+studio_readiness.py — InScript v2.12.0  Studio Readiness Gate
+================================================================
+`inscript --check-v3` runs all seven readiness gates and exits 0
+only when every gate passes.  This is the final checkpoint before
+v3.0.0 InScript Studio development can safely begin.
+
+Gates
+─────
+  G1  60fps performance gate     — 1000 NodeInstance._update calls in < 33ms
+  G2  Memory gate                — < 2MB growth over 5000 game-loop iterations
+  G3  Language stability audit   — all CI test files found and importable
+  G4  Error JSON stream          — InScriptError.to_dict() / to_json() work
+  G5  Electron bridge            — StudioBridge starts + responds to ping
+  G6  Plugin API                 — StudioAPI register/emit round-trip
+  G7  Project introspection      — project_inspect returns well-formed JSON
+
+If all pass, prints a v3.0.0 green-light banner.
+"""
+
+from __future__ import annotations
+import sys, os, time, tracemalloc, json, threading
+from typing import List, Tuple
+
+GATE_COUNT = 7
+
+# ─────────────────────────────────────────────────────────────────────────────
+# GateResult
+# ─────────────────────────────────────────────────────────────────────────────
+
+class GateResult:
+    def __init__(self, gate_id: int, name: str, passed: bool,
+                 detail: str = "", elapsed_ms: float = 0.0):
+        self.gate_id    = gate_id
+        self.name       = name
+        self.passed     = passed
+        self.detail     = detail
+        self.elapsed_ms = elapsed_ms
+
+    def __repr__(self):
+        icon = "✅" if self.passed else "❌"
+        ms   = f" ({self.elapsed_ms:.1f}ms)" if self.elapsed_ms else ""
+        return f"  {icon}  G{self.gate_id}: {self.name}{ms}  {self.detail}"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# G1 — 60fps performance gate
+# ─────────────────────────────────────────────────────────────────────────────
+
+# Threshold: 1000 NodeInstance._update calls must complete in under 33ms
+# (= 30fps minimum; any modern machine will be well above 60fps)
+PERF_THRESHOLD_MS = 33.0
+PERF_NODE_COUNT   = 1000
+
+def gate_performance() -> GateResult:
+    """
+    Instantiate PERF_NODE_COUNT NodeInstances each with an _update(dt) hook
+    and measure how long one full update pass takes.
+    """
+    t0 = time.perf_counter()
+    try:
+        from interpreter import Interpreter
+        from scene_tree   import NodeBlueprint, NodeInstance
+
+        src = "node PerfNode { let c: int = 0\n_update(dt) { c = c + 1 } }"
+        interp = Interpreter()
+        interp.execute(src)
+        bp = interp._globals._store.get("PerfNode")
+        if bp is None:
+            return GateResult(1, "60fps performance gate", False,
+                              "PerfNode blueprint not found", 0.0)
+
+        # Create PERF_NODE_COUNT instances
+        instances = [bp.instantiate(f"n{i}") for i in range(PERF_NODE_COUNT)]
+
+        # Time one full update pass
+        t_start = time.perf_counter()
+        for inst in instances:
+            inst.call_update(0.016)
+        t_end   = time.perf_counter()
+        elapsed = (t_end - t_start) * 1000
+
+        fps_equiv = 1000.0 / elapsed if elapsed > 0 else float("inf")
+        detail = (f"{PERF_NODE_COUNT} nodes updated in {elapsed:.1f}ms "
+                  f"(≈{fps_equiv:.0f}fps equiv)")
+        passed = elapsed < PERF_THRESHOLD_MS
+        if not passed:
+            detail += f" — SLOW (threshold {PERF_THRESHOLD_MS}ms)"
+        return GateResult(1, "60fps performance gate", passed, detail,
+                          (time.perf_counter() - t0) * 1000)
+    except Exception as e:
+        return GateResult(1, "60fps performance gate", False, str(e),
+                          (time.perf_counter() - t0) * 1000)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# G2 — Memory gate
+# ─────────────────────────────────────────────────────────────────────────────
+
+MEMORY_ITERATIONS  = 5000
+MEMORY_LIMIT_BYTES = 2 * 1024 * 1024  # 2 MB
+
+def gate_memory() -> GateResult:
+    """
+    Run MEMORY_ITERATIONS of a minimal game loop and measure growth via tracemalloc.
+    A leaky interpreter would show unbounded growth.
+    """
+    t0 = time.perf_counter()
+    try:
+        from interpreter import Interpreter
+
+        interp = Interpreter()
+        interp.execute("let tick: int = 0\nfn update(dt) { tick = tick + 1 }")
+        update_fn = interp._globals._store.get("update")
+
+        tracemalloc.start()
+        snapshot_before = tracemalloc.take_snapshot()
+
+        for _ in range(MEMORY_ITERATIONS):
+            interp._call_fn(update_fn, [0.016])
+
+        snapshot_after = tracemalloc.take_snapshot()
+        tracemalloc.stop()
+
+        stats  = snapshot_after.compare_to(snapshot_before, "lineno")
+        growth = sum(s.size_diff for s in stats if s.size_diff > 0)
+
+        detail = f"{growth / 1024:.1f}KB growth over {MEMORY_ITERATIONS} iterations"
+        passed = growth < MEMORY_LIMIT_BYTES
+        if not passed:
+            detail += f" — LEAK (limit {MEMORY_LIMIT_BYTES // 1024}KB)"
+        return GateResult(2, "Memory gate", passed, detail,
+                          (time.perf_counter() - t0) * 1000)
+    except Exception as e:
+        return GateResult(2, "Memory gate", False, str(e),
+                          (time.perf_counter() - t0) * 1000)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# G3 — Language stability audit
+# ─────────────────────────────────────────────────────────────────────────────
+
+REQUIRED_TEST_FILES = [
+    "test_v260.py", "test_v270.py", "test_v280.py",
+    "test_v290.py", "test_v2100.py", "test_v2110.py",
+]
+
+def gate_stability(base_dir: str = ".") -> GateResult:
+    """
+    Verify that all required CI test files exist and are importable.
+    Full execution is handled by the publish.yml workflow.
+    """
+    t0 = time.perf_counter()
+    missing = []
+    for fn in REQUIRED_TEST_FILES:
+        if not os.path.isfile(os.path.join(base_dir, fn)):
+            missing.append(fn)
+
+    if missing:
+        detail = f"Missing test files: {missing}"
+        return GateResult(3, "Language stability audit", False, detail,
+                          (time.perf_counter() - t0) * 1000)
+
+    # Quick import check
+    import_errors = []
+    for fn in ["lexer", "parser", "interpreter", "scene_tree",
+               "hot_reload", "stdlib_assets", "export_pipeline",
+               "studio_bridge", "inscript_studio_api"]:
+        try:
+            __import__(fn)
+        except Exception as e:
+            import_errors.append(f"{fn}: {e}")
+
+    passed = not missing and not import_errors
+    detail = (f"All {len(REQUIRED_TEST_FILES)} test files present; "
+              f"{len(import_errors)} import error(s)")
+    if import_errors:
+        detail += f": {import_errors}"
+    return GateResult(3, "Language stability audit", passed, detail,
+                      (time.perf_counter() - t0) * 1000)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# G4 — Error JSON stream
+# ─────────────────────────────────────────────────────────────────────────────
+
+def gate_error_json() -> GateResult:
+    """Verify InScriptError.to_dict() and to_json() produce valid JSON."""
+    t0 = time.perf_counter()
+    try:
+        from errors import NameError_ as _NE
+
+        # Raise a real InScript error and check serialisation
+        err = _NE("Test variable not found", line=5, col=3,
+                  source_line="let x = undefined_var", hint="Did you mean 'x'?")
+        d = err.to_dict()
+
+        # Validate required fields
+        required = {"type", "code", "class", "message", "line", "col"}
+        missing  = required - set(d.keys())
+        if missing:
+            return GateResult(4, "Error JSON stream", False,
+                              f"Missing keys: {missing}",
+                              (time.perf_counter() - t0) * 1000)
+
+        # Validate to_json() is valid JSON
+        raw   = err.to_json()
+        reparsed = json.loads(raw)
+
+        checks = [
+            d["type"] == "error",
+            d["line"] == 5,
+            d["col"]  == 3,
+            d["hint"] == "Did you mean 'x'?",
+            reparsed["code"] == d["code"],
+        ]
+        passed = all(checks)
+        detail = f"to_dict() has {len(d)} keys; to_json() round-trips OK"
+        return GateResult(4, "Error JSON stream", passed, detail,
+                          (time.perf_counter() - t0) * 1000)
+    except Exception as e:
+        return GateResult(4, "Error JSON stream", False, str(e),
+                          (time.perf_counter() - t0) * 1000)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# G5 — Electron bridge
+# ─────────────────────────────────────────────────────────────────────────────
+
+BRIDGE_TEST_PORT = 18999
+
+def gate_bridge() -> GateResult:
+    """Start StudioBridge on a test port and verify ping round-trip."""
+    t0 = time.perf_counter()
+    try:
+        import urllib.request as _ur
+        from studio_bridge import StudioBridge
+
+        bridge = StudioBridge(port=BRIDGE_TEST_PORT)
+        bridge.start()
+        time.sleep(0.1)   # allow server thread to start
+
+        req  = _ur.Request(
+            bridge.url,
+            data=json.dumps({"method": "ping", "id": 1}).encode(),
+            headers={"Content-Type": "application/json"},
+        )
+        resp = _ur.urlopen(req, timeout=3)
+        body = json.loads(resp.read().decode())
+        bridge.stop()
+
+        passed = body.get("result", {}).get("pong") is True
+        detail = f"Ping response: {body.get('result')}"
+        return GateResult(5, "Electron bridge (ping)", passed, detail,
+                          (time.perf_counter() - t0) * 1000)
+    except Exception as e:
+        return GateResult(5, "Electron bridge (ping)", False, str(e),
+                          (time.perf_counter() - t0) * 1000)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# G6 — Plugin API
+# ─────────────────────────────────────────────────────────────────────────────
+
+def gate_plugin_api() -> GateResult:
+    """Register a plugin, emit events, verify it received them."""
+    t0 = time.perf_counter()
+    try:
+        from inscript_studio_api import StudioAPI, StudioPlugin
+
+        received: list = []
+
+        class _TestPlugin(StudioPlugin):
+            name = "test_plugin"
+            def on_error(self, error):    received.append(("error", error))
+            def on_reload(self, result):  received.append(("reload", result))
+            def on_build(self, t, d, s):  received.append(("build", t, s))
+
+        api = StudioAPI()
+        p   = _TestPlugin()
+        api.register(p)
+
+        api.emit_error({"code": "E0042", "message": "test"})
+        api.emit_reload({"success": True})
+        api.emit_build("desktop", "/out", True)
+
+        checks = [
+            api.plugin_count() == 1,
+            len(received) == 3,
+            received[0][0] == "error",
+            received[1][0] == "reload",
+            received[2][0] == "build",
+        ]
+        api.unregister(p)
+        checks.append(api.plugin_count() == 0)
+
+        passed = all(checks)
+        detail = f"3/3 events received; register/unregister OK"
+        return GateResult(6, "Plugin API", passed, detail,
+                          (time.perf_counter() - t0) * 1000)
+    except Exception as e:
+        return GateResult(6, "Plugin API", False, str(e),
+                          (time.perf_counter() - t0) * 1000)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# G7 — Project introspection
+# ─────────────────────────────────────────────────────────────────────────────
+
+def gate_introspection(base_dir: str = ".") -> GateResult:
+    """Run project_inspect on a minimal temp project and verify JSON output."""
+    t0 = time.perf_counter()
+    try:
+        import tempfile, shutil
+        from inscript_studio_api import project_inspect
+
+        tmp = tempfile.mkdtemp(prefix="inscript_gate7_")
+        try:
+            os.makedirs(os.path.join(tmp, "src"))
+            os.makedirs(os.path.join(tmp, "scenes"))
+            with open(os.path.join(tmp, "src", "main.ins"), "w") as f:
+                f.write('node Player { let hp: int = 100\n_update(dt) { } }\n'
+                        'fn spawn(x, y) { }\n'
+                        '@texture("sprites/hero.png")\nlet hero_tex\n')
+            with open(os.path.join(tmp, "scenes", "level1.inscene"), "w") as f:
+                f.write('[scene]\nname = "level1"\nroot = "Player"\n')
+
+            data = project_inspect(tmp)
+
+            # Validate structure
+            required_keys = {"project_dir", "version", "sources", "scenes",
+                             "nodes", "functions", "assets", "scene_files"}
+            missing = required_keys - set(data.keys())
+            if missing:
+                return GateResult(7, "Project introspection", False,
+                                  f"Missing keys: {missing}",
+                                  (time.perf_counter() - t0) * 1000)
+
+            # Validate JSON-serialisable
+            json.dumps(data)
+
+            has_player   = any(n["name"] == "Player" for n in data["nodes"])
+            has_spawn    = any(f["name"] == "spawn"   for f in data["functions"])
+            has_texture  = any(a["type"] == "texture"  for a in data["assets"])
+            has_scene    = any(s.get("scene_name") == "level1" for s in data["scene_files"])
+
+            checks = [has_player, has_spawn, has_texture, has_scene]
+            passed = all(checks)
+            detail = (f"nodes={len(data['nodes'])} fns={len(data['functions'])} "
+                      f"assets={len(data['assets'])} scene_files={len(data['scene_files'])}")
+            return GateResult(7, "Project introspection", passed, detail,
+                              (time.perf_counter() - t0) * 1000)
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+    except Exception as e:
+        return GateResult(7, "Project introspection", False, str(e),
+                          (time.perf_counter() - t0) * 1000)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Main gate runner
+# ─────────────────────────────────────────────────────────────────────────────
+
+def run_all_gates(base_dir: str = ".") -> Tuple[List[GateResult], bool]:
+    """Run all 7 gates. Returns (results, all_passed)."""
+    print("\n╔══════════════════════════════════════════════════════════╗")
+    print("║   InScript v3.0.0 Readiness Gate  (inscript check-v3)  ║")
+    print("╚══════════════════════════════════════════════════════════╝\n")
+
+    runners = [
+        lambda: gate_performance(),
+        lambda: gate_memory(),
+        lambda: gate_stability(base_dir),
+        lambda: gate_error_json(),
+        lambda: gate_bridge(),
+        lambda: gate_plugin_api(),
+        lambda: gate_introspection(base_dir),
+    ]
+
+    results = []
+    for runner in runners:
+        r = runner()
+        print(repr(r))
+        results.append(r)
+
+    passed_count = sum(1 for r in results if r.passed)
+    all_passed   = passed_count == GATE_COUNT
+
+    print(f"\n{'─'*60}")
+    print(f"Gates passed: {passed_count}/{GATE_COUNT}")
+
+    if all_passed:
+        print("""
+╔══════════════════════════════════════════════════════════╗
+║  🟢  ALL GATES PASS — v3.0.0 InScript Studio is GO!     ║
+║                                                          ║
+║  Scene system, asset pipeline, hot reload, physics,      ║
+║  multiplayer, export pipeline, and Studio bridge are     ║
+║  all in place.  Begin v3.0.0 development.                ║
+╚══════════════════════════════════════════════════════════╝""")
+    else:
+        failed = [r for r in results if not r.passed]
+        print(f"\n🔴  {len(failed)} gate(s) failed — NOT ready for v3.0.0:")
+        for r in failed:
+            print(f"     G{r.gate_id}: {r.name} — {r.detail}")
+
+    return results, all_passed