ranger-compiler 3.0.5 → 3.1.0

package/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.1.0] - 2026-06-02
+
+### Added
+
+- **`ProcessUiHost` notify suppress** — `beginSuppressUiNotify` / `endSuppressUiNotify` / `isUiNotifySuppressed` for batching parent↔child sync without re-entrant UI notify loops ([PROCESS_UI_NOTIFY.md](PROCESS_UI_NOTIFY.md))
+- **Process view DTO regression fixture** — [tests/fixtures/process_view_dto_assign.rgr](tests/fixtures/process_view_dto_assign.rgr) (cross-class field assignment with method call on RHS)
+- **Docs** — [PROCESS_UI_NOTIFY.md](PROCESS_UI_NOTIFY.md), [PROCESS_UI_VIEW_MODELS.md](PROCESS_UI_VIEW_MODELS.md); README `@process` quick start
+
+### Fixed
+
+- **Parser: assignment RHS method calls** — `row.field = this.helper(index)` no longer splits the call into invalid `=` operands ([PROCESS_UI_VIEW_MODELS.md](PROCESS_UI_VIEW_MODELS.md)); fix in [compiler/ng_RangerFlowParser.rgr](compiler/ng_RangerFlowParser.rgr) (`repairAssignMethodCallRhs`)
+
+### Changed
+
+- Version bumped from `3.0.5` to `3.1.0`
+
 ## [3.0.5] - 2026-05-29
 
 ### Added

package/README.md

@@ -1,6 +1,6 @@
 # Ranger cross language compiler
 
-**Version 3.0.5** | Status: `experimental`
+**Version 3.1.0** | Status: `experimental`
 
 Ranger is a self-hosting cross-language compiler for writing portable algorithms, parsers, generators, and small tools once and compiling them to multiple target languages.
 
@@ -25,8 +25,42 @@ Ranger is best approached today as a compiler and language lab with practical mu
 
 If you want one sentence of positioning: Ranger is currently more convincing as a portable algorithm compiler / DSL toolchain than as a drop-in replacement for mainstream application languages.
 
+## `@process` runtime (experimental)
+
+Ranger can mark classes with `@process` to get a **small object runtime** in generated code (especially JavaScript/TypeScript): parent/child tree, instance registry, `proc_start` / `proc_stop`, and UI refresh via `markStateDirty()`.
+
+| Piece | What it does |
+| --- | --- |
+| `@process` / `@process(true)` | Process instance with lifecycle hooks (`start`, `stop`, …) |
+| `proc_start` / `proc_stop` | Activate or tear down a process subtree (children first) |
+| `proc_send target handler arg…` | Typed message dispatch to `fn on…` handlers on a live instance |
+| `ProcessNameRegistry.findProcess(path)` | Lookup by `@name("app.foo")` (TypeScript path literals when using `-typescript`) |
+| `markStateDirty()` | Bump generation + notify host (`ProcessUiHost`) for UI binding |
+| `beginSuppressUiNotify` / `endSuppressUiNotify` | Batch parent↔child sync without notify storms |
+
+**Typical app shape:** domain logic and UI flags live in `@process` classes; **view DTOs** are plain Ranger classes filled by a builder; React/CLI/native hosts subscribe to `ProcessUiHost` and call `findProcess` — I/O and async work stay in the host (Node, Swift, …), not inside the process bytecode.
+
+```ranger
+class CounterPage @process @name("app.counter") extends RangerProcessBase {
+  def count:int 0
+  fn onUiIncrement:void () {
+    count = count + 1
+    this.markStateDirty()
+  }
+}
+```
+
+```typescript
+// Host (TypeScript): wire notify once, then bind UI to process fields
+const host = ProcessUiHost.__singleton();
+host.notifyPath = (path) => { /* sync view model + re-render */ };
+```
+
+**Docs:** [PROCESS_MVP.md](PROCESS_MVP.md) (scope), [PROCESS_STATUS.md](PROCESS_STATUS.md) (compiler checklist), [PROCESS_UI_NOTIFY.md](PROCESS_UI_NOTIFY.md) (notify batching), [PROCESS_UI_VIEW_MODELS.md](PROCESS_UI_VIEW_MODELS.md) (view DTO assignment). **Gallery:** [process_counter_board](gallery/process_counter_board/README.md). **Pilot:** [realtrainer `app-ranger` Active Workout demo](https://github.com/terotests/realtrainer/tree/copilot/create-watch-ui-components/app-ranger/demo/active-workout-process).
+
 ## Where To Start
 
+- [Online playground](https://terotests.github.io/Ranger/) — try Ranger in the browser (`playground/`, Vite + current compiler)
 - `README.md` - language overview, installation, and syntax notes
 - `ai/QUICKREF.md` - fast reference for syntax and core concepts
 - `ai/INSTRUCTIONS.md` - fuller language guide for operators, templates, and compiler concepts

package/dist/Lang.rgr

@@ -193,9 +193,11 @@ language {
             templates {
                 ranger ("(cast " (e 1) " " (e 2) ":" (typeof 2) " )")
                 ts ( (e 1) " as " (typeof 2) )
+                kotlin ( (e 1) " as " (typeof 2) )
                 es6 ( (e 1) )
                 java7 ( "((" (typeof 2) ")" (e 1) ")" )
                 swift3 ( (e 1) " as " (typeof 2) "" )
+                swift6 ( (e 1) " as " (typeof 2) "" )
                 cpp ( "mpark::get<" (typeof 2) ">(" (e 1) ")" 
                 
                     (plugin 'makefile' ((dep 'variant.hpp' 'https://github.com/mpark/variant/releases/download/v1.2.2/variant.hpp')))            
@@ -5349,25 +5351,7 @@ std::string r_cpp_str_to_uppercase(std::string original)
             }
         }
 
-        proc_send@(moves@( 2 )) cmdProcSendPath:void (path:string msg:Any) {
-            templates {
-                es6 ( "(() => { const __rgrP = ProcessNameRegistry.__singleton().findByPath(" (e 1) "); if (!__rgrP || __rgrP.__rangerId === 0) return; __rgrP.receiveMessage(" (e 2) "); })()" )
-                kotlin ( "run { val __rgrP = ProcessNameRegistry.__singleton().findByPath(" (e 1) "); if (__rgrP == null || __rgrP.__rangerId == 0) return@run; __rgrP.receiveMessage(" (e 2) ") }" )
-                swift6 ( "{ let __rgrP = ProcessNameRegistry.__singleton().findByPath(" (e 1) "); guard let p = __rgrP, p.__rangerId != 0 else { return }; p.receiveMessage(" (e 2) ") }" )
-                swift3 ( "{ let __rgrP = ProcessNameRegistry.__singleton().findByPath(" (e 1) "); guard let p = __rgrP, p.__rangerId != 0 else { return }; p.receiveMessage(" (e 2) ") }" )
-                * ( "/* proc_send path not implemented */" )
-            }
-        }
-
-        proc_send@(moves@( 2 )) cmdProcSendProc:void (proc:RangerProcessBase msg:Any) {
-            templates {
-                es6 ( "(() => { const __rgrP = " (e 1) "; if (!__rgrP || __rgrP.__rangerId === 0) return; __rgrP.receiveMessage(" (e 2) "); })()" )
-                kotlin ( "run { val __rgrP = " (e 1) "; if (__rgrP.__rangerId == 0) return@run; __rgrP.receiveMessage(" (e 2) ") }" )
-                swift6 ( "{ let __rgrP = " (e 1) "; guard __rgrP.__rangerId != 0 else { return }; __rgrP.receiveMessage(" (e 2) ") }" )
-                swift3 ( "{ let __rgrP = " (e 1) "; guard __rgrP.__rangerId != 0 else { return }; __rgrP.receiveMessage(" (e 2) ") }" )
-                * ( "/* proc_send proc not implemented */" )
-            }
-        }
+        ; proc_send is lowered in ng_RangerProcessProcSend.rgr (typed handler methods, overload match).
 
         proc_start@(moves@( 1 )) cmdProcStart:void (proc:RangerProcessBase) {
             templates {

package/dist/lib/RangerProcess.rgr

@@ -11,13 +11,27 @@ class RangerProcessBase {
   def __rangerParent:RangerProcessBase@(optional)
   def __rangerChildren:[RangerProcessBase]
 
+  ; Bump revision only (e.g. parent sync merging child pending*). Prefer over markStateDirty in sync blocks.
+  fn bumpStateGeneration:void () {
+    __rangerStateGeneration = __rangerStateGeneration + 1
+  }
+
   fn markStateDirty:void () {
     __rangerStateGeneration = __rangerStateGeneration + 1
+    this.flushUiNotify()
+  }
+
+  ; Notify host without bumping __rangerStateGeneration (after suppressUiNotify batch).
+  fn flushUiNotify:void () {
+    def uiHost:ProcessUiHost (ProcessUiHost.__singleton())
+    if (uiHost.isUiNotifySuppressed()) {
+      return
+    }
     if ((strlen __rangerPath) > 0) {
-      ProcessUiHost.__singleton().notifyPath(__rangerPath)
+      uiHost.notifyPath(__rangerPath)
     }
     if (__rangerId != 0) {
-      ProcessUiHost.__singleton().notifyId(__rangerId)
+      uiHost.notifyId(__rangerId)
     }
   }
 
@@ -57,8 +71,8 @@ class RangerProcessBase {
   fn __rangerStopSubtree:void () {
   }
 
-  ; Optional inbound messaging hook; override on @process classes. proc_send calls this.
-  fn receiveMessage:void (msg:Any) {
+  ; Legacy hook; prefer typed proc_send → handler methods on @process classes.
+  fn receiveMessage:void (name:string value:string) {
   }
 }
 
@@ -123,7 +137,24 @@ class ProcessNameRegistry @singleton(true) {
 }
 
 ; Host-side UI subscriptions (React useProcess wires listeners in TS).
+; Hosts may replace notifyPath/notifyId on the singleton instance; markStateDirty respects suppressUiNotify.
 class ProcessUiHost @singleton(true) {
+  def __uiNotifySuppressDepth:int 0
+
+  fn isUiNotifySuppressed:boolean () {
+    return __uiNotifySuppressDepth > 0
+  }
+
+  fn beginSuppressUiNotify:void () {
+    __uiNotifySuppressDepth = __uiNotifySuppressDepth + 1
+  }
+
+  fn endSuppressUiNotify:void () {
+    if (__uiNotifySuppressDepth > 0) {
+      __uiNotifySuppressDepth = __uiNotifySuppressDepth - 1
+    }
+  }
+
   fn notifyPath:void (path:string) {
   }