feat: Add ProXWire runtime implementation and LSP prototype with taint token highlighting

Author: ProgrammerKR

docs/expansion_plan/ProXWire_RUNTIME.md

@@ -0,0 +1,41 @@
+ProXWire Runtime: Implementation Sketch
+======================================
+
+This document expands the ProXWire design with more implementation details and integration points with `prox.net.shield` and the Context-Aware scheduler.
+
+Dispatch
+--------
+- Intent signature: canonical string `domain:action:accepts` used as a trie key.
+- Router stores precompiled sanitizer & serializer pipelines keyed by intent.
+- Dispatch path:
+  1. Transport receives bytes -> wraps as `Tainted[Bytes]` with metadata.
+  2. `prox.net.shield.auto_sanitize` runs pipeline for intent; returns `Sanitized[T]`.
+  3. Dispatcher schedules handler with `Context`.
+
+Scheduler integration
+---------------------
+- Handlers are scheduled with `Context` describing `intent`, `priority_hint`, `ttl`, and `taint_level`.
+- Fast lanes: runtime maintains dedicated worker pools per intent priority.
+
+Optimizations
+-------------
+- Precompile sanitizer pipeline into an efficient C++ fast-path for common schemas.
+- Inline intent matching where header `X-Intent` exists, fallback to content-based inference.
+
+Example (lowering sketch)
+-------------------------
+// High-level route
+@intent(domain:"user", action:"create", accepts:"application/json")
+async fn create_user(req: Sanitized[UserCreate], ctx: Context) -> JSON { ... }
+
+// Compiler output (sketch):
+// 1) Register intent signature and sanitizer at module init
+prox.net.shield.register_sanitizer("user:create:application/json", compiled_pipeline)
+ProXWire.Router.register_handler("user:create:application/json", &create_user_wrapper)
+
+// 2) Wrapper ensures typed call
+fn create_user_wrapper(raw_req, ctx) {
+  let sanitized = prox.net.shield.auto_sanitize(raw_req.tainted, "user:create:application/json")
+  if sanitized.is_err() { return Response(400) }
+  return create_user(sanitized.unwrap(), ctx)
+}

libs/proxwire.prox

@@ -0,0 +1,59 @@
+// ProXWire runtime skeleton (pseudo-ProXPL)
+module ProXWire {
+
+  type Intent = { domain: Str, action: Str, accepts: Str, produces: Str }
+
+  // Router compiles an intent trie for fast dispatch
+  struct Router {
+    // internal: map from intent signature -> handler
+    handlers: Map[Str, fn(Sanitized[Bytes], Context) -> Response]
+
+    fn add_intent(handler_fn) {
+      // compiler/runtime introspects handler to extract `@intent` metadata
+      sig = handler_fn.intent_signature
+      handlers.insert(sig, handler_fn)
+    }
+
+    fn dispatch(req: Request, ctx: Context) -> Response {
+      // Determine intent from request (headers / route hints)
+      sig = infer_intent(req)
+      let handler = handlers.get(sig)
+      if handler == None {
+        return Response(404)
+      }
+      // Shield sanitization: auto-sanitize before calling handler
+      let sanitized = prox.net.shield.auto_sanitize(req.body.tainted, sig)
+      if sanitized.is_err() {
+        return Response(400, body: { error: sanitized.err })
+      }
+      // schedule as async task with Context
+      return spawn_task(handler, sanitized.unwrap(), ctx)
+    }
+  }
+
+  // Server harness (simplified)
+  struct Server {
+    router: Router
+
+    fn new(router: Router) -> Server { Server{router} }
+
+    fn listen(addr: Str, port: Int) {
+      // transport loop (HTTP/TCP) receives `Request` objects
+      for req in Transport.accept(addr, port) {
+        // build context from request metadata
+        ctx = Context(intent: infer_intent(req), priority_hint: 0, ttl: 30s, taint_level: 1.0)
+        // dispatch (non-blocking)
+        _ = router.dispatch(req, ctx)
+      }
+    }
+  }
+
+  // Example helper: spawn async task using runtime scheduler
+  fn spawn_task(handler, sanitized, ctx) -> Response {
+    // runtime: create task descriptor with Context fields
+    task = Task.create(handler, sanitized, ctx)
+    Scheduler.enqueue(task)
+    return Response(202) // accepted; real response may be awaited
+  }
+
+}

lsp/README.md

@@ -0,0 +1,23 @@
+ProXPL LSP Prototype
+=====================
+
+This folder contains a minimal LSP prototype that highlights identifiers prefixed with `taint_` as tainted tokens.
+
+Setup
+-----
+Install dependencies in a virtualenv:
+
+```powershell
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+```
+
+Run
+---
+
+```powershell
+python proxpl_lsp_taint.py
+```
+
+Note: This is a minimal prototype for demonstration. Integrating with editors requires providing the appropriate semantic token legend and mapping token types on the client.

lsp/proxpl_lsp_taint.py

@@ -0,0 +1,48 @@
+"""
+Minimal ProXPL LSP prototype that highlights tokens prefixed with 'taint_' as `tainted`.
+This uses `pygls` as a demonstration. Install with `pip install -r requirements.txt`.
+"""
+from pygls.server import LanguageServer
+from pygls.lsp.types import (DidOpenTextDocumentParams, DidChangeTextDocumentParams,
+                             InitializeParams, TextDocumentItem, Position,
+                             Range, SemanticTokens, SemanticTokensLegend,
+                             SemanticTokensParams)
+from pygls.lsp.types import SemanticTokens, SemanticTokensParams
+
+import re
+
+SERVER = LanguageServer('proxpl-lsp', 'v0.1')
+
+TAINT_TOKEN_TYPE = 100  # custom type index (client must map)
+
+@SERVER.feature('textDocument/didOpen')
+def did_open(ls: LanguageServer, params: DidOpenTextDocumentParams):
+    doc = params.text_document
+    publish_taint_tokens(ls, doc.text, doc.uri)
+
+@SERVER.feature('textDocument/didChange')
+def did_change(ls: LanguageServer, params: DidChangeTextDocumentParams):
+    doc = ls.workspace.get_document(params.text_document.uri)
+    publish_taint_tokens(ls, doc.source, doc.uri)
+
+def publish_taint_tokens(ls: LanguageServer, text: str, uri: str):
+    tokens = []  # as list of integers per LSP: [line, startChar, length, tokenType, tokenModifiers]
+    for lineno, line in enumerate(text.splitlines()):
+        for m in re.finditer(r"\btaint_[A-Za-z0-9_]+\b", line):
+            start = m.start()
+            length = m.end() - m.start()
+            tokens.extend([lineno, start, length, TAINT_TOKEN_TYPE, 0])
+    st = SemanticTokens(data=tokens)
+    # Semantic token publishing uses a custom notification for simplicity
+    ls.show_message_log(f"Publishing {len(tokens)//5} taint tokens for {uri}")
+    ls.send_notification('textDocument/semanticTokens', {'uri': uri, 'tokens': tokens})
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--tcp', action='store_true', help='Run LSP server over stdio (default)')
+    args = parser.parse_args()
+    SERVER.start_io()
+
+if __name__ == '__main__':
+    main()

lsp/requirements.txt

@@ -0,0 +1 @@
+pygls>=0.13.0

tools/build_asr_demo_vs.bat

@@ -0,0 +1,17 @@
+@echo off
+REM build_asr_demo_vs.bat
+REM Compile the ASR demo using MSVC `cl` (Developer Command Prompt)
+
+IF "%1"=="clean" GOTO :clean
+
+IF NOT EXIST build (
+  mkdir build
+)
+
+echo Compiling with MSVC cl...
+cl /EHsc /O2 runtime\asr_lockfree_queue.cpp runtime\asr_supervisor.cpp tests\asr_queue_test.cpp /Fe:build\asr_test.exe
+exit /b %errorlevel%
+
+:clean
+del build\asr_test.exe
+exit /b 0