ranger-compiler 3.0.4 → 3.1.0

package/CHANGELOG.md

@@ -7,6 +7,38 @@ 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
+
+- **`@process` messaging** — `proc_send` operator; `receiveMessage` on `RangerProcessBase`; `find_process` / `ProcessNameRegistry.findProcess`
+- **TypeScript named paths** — `-typescript` emits `ProcessPath`, `findProcess` on registry, singleton `new` returns shared instance
+- **`RangerProcess.rgr` in npm lib** — included under `dist/lib/` when running `npm run build:dist`
+
+### Fixed
+
+- **`build:dist:copy`** — `rm -rf dist/lib` before copy so new lib files (e.g. `RangerProcess.rgr`) land in `dist/lib/` instead of nested `dist/lib/lib/`
+
+### Changed
+
+- Version bumped from `3.0.4` to `3.0.5`
+
 ## [3.0.4] - 2026-05-12
 
 ### Fixed

package/README.md

@@ -1,6 +1,6 @@
 # Ranger cross language compiler
 
-**Version 3.0.4** | 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')))            
@@ -493,6 +495,7 @@ func r_io_get_env( name string) *GoNullable {
                 swift6 ("CommandLine.arguments[" (e 1) " + 1]")
                 es6 ( "process.argv[ 2 + " (e 1) "]")
                 rust ( "std::env::args().nth((" (e 1) " + 1) as usize).unwrap_or_default()")
+                kotlin ( "args[" (e 1) "]")
                 ranger ("( shell_arg " (e 1) " )")
             }
         }
@@ -508,6 +511,7 @@ func r_io_get_env( name string) *GoNullable {
                 go ( "int64( len( os.Args) - 1 )"  (imp "os"))
                 es6 ( "(process.argv.length - 2)" )
                 rust ( "(std::env::args().len() as i64 - 1)")
+                kotlin ( "(args.size - 1)")
                 ranger ("( shell_arg_cnt )")
             }
         }        
@@ -930,6 +934,7 @@ fn r_read_file(path: &str, filename: &str) -> Option<String> {
 }
 "))
                 es6 ( "(require('fs').readFileSync( " (e 1) " + '/' + " (e 2) " , 'utf8'))" )
+                kotlin ( "try { java.io.File(if (" (e 1) ".isEmpty()) " (e 2) " else " (e 1) " + \"/\" + " (e 2) ").readText() } catch (_: Exception) { null }" (imp "java.io.File") )
             }
         }
 
@@ -2716,6 +2721,7 @@ std::vector<uint8_t> r_buffer_read_file(const std::string& path, const std::stri
                 ranger ( "(to_int " (e 1) ")") 
                 csharp ( "(int)" (e 1 ) "" )
                 swift3 ( "Int(" (e 1 ) ")" )
+                swift6 ( "Int(" (e 1 ) ")" )
                 kotlin ( (e 1 ) ".toInt()" )
                 scala ( (e 1 ) ".toInt" )
                 rust ( (e 1 ) " as i64 " )
@@ -3165,9 +3171,50 @@ func r_str_2_i64(s string) *GoNullable {
                 )
                 php ( "is_numeric(" (e 1) ") ? intval(" (e 1) ") : NULL ")
                 scala ( "Try(" (e 1) ".toInt).toOption" (imp "scala.util.Try"))
-                kotlin (  (e 1) ".toIntOrNull()")
-                swift3 ("Int(" (e 1) ")")
-                swift6 ("Int(" (e 1) ")")
+                kotlin ( "rangerStr2IntPrefix(" (e 1) ")"
+(create_polyfill "
+fun rangerStr2IntPrefix(s: String): Int? {
+  val m = Regex(\"^-?\\\\d+\").find(s) ?: return null
+  return m.value.toIntOrNull()
+}
+")
+                )
+                swift3 ("rangerStr2IntPrefix(" (e 1) ")"
+(create_polyfill "
+func rangerStr2IntPrefix(_ s: String) -> Int? {
+  var i = s.startIndex
+  if i < s.endIndex && s[i] == \"-\" {
+    i = s.index(after: i)
+  }
+  var end = i
+  while end < s.endIndex && s[end].isNumber {
+    end = s.index(after: end)
+  }
+  if end == i {
+    return nil
+  }
+  return Int(s[i..<end])
+}
+")
+                )
+                swift6 ("rangerStr2IntPrefix(" (e 1) ")"
+(create_polyfill "
+func rangerStr2IntPrefix(_ s: String) -> Int? {
+  var i = s.startIndex
+  if i < s.endIndex && s[i] == \"-\" {
+    i = s.index(after: i)
+  }
+  var end = i
+  while end < s.endIndex && s[end].isNumber {
+    end = s.index(after: end)
+  }
+  if end == i {
+    return nil
+  }
+  return Int(s[i..<end])
+}
+")
+                )
                 csharp( "Int32.Parse(" (e 1) ")" )
                 rust ( (e 1) ".parse::<i64>().ok()" )
                 * ( "isNaN( parseInt(" (e 1) ") ) ? undefined : parseInt(" (e 1) ")")
@@ -3247,7 +3294,7 @@ Double _getDoubleOrNull ( String str ) {
                 scala ( "Try(" (e 1) ".toDouble).toOption" (imp "scala.util.Try"))
                 kotlin (  (e 1) ".toDoubleOrNull()")
                 swift3 ("Double(" (e 1) ")")
-                rust ( (e 1) ".parse::<f64>().ok()" )
+                swift6 ("Double(" (e 1) ")")
                 * ( "isNaN( parseFloat(" (e 1) ") ) ? undefined : parseFloat(" (e 1) ")")
             }
         }
@@ -4090,9 +4137,12 @@ public <T> T _arr_extract( ArrayList<T> list, Integer i )  {
                     "const readline = require('readline');" nl
                     "readline.emitKeypressEvents(process.stdin);" nl
                     "if (process.stdin.isTTY) { process.stdin.setRawMode(true); }" nl
-                    "process.stdin.on('keypress', (" (e 1) ", data) => {" nl I
-                    "if (data && data.ctrl && data.name === 'c') { process.stdout.write('\\x1b[?25h'); process.exit(); }" nl
-                    "if (data && data.name) { " (e 1) " = data.name; global.r_key_queue.push(" (e 1) "); }" nl
+                    "process.stdin.resume();" nl
+                    "process.stdin.on('keypress', (str, key) => {" nl I
+                    "if (key && key.ctrl && key.name === 'c') { process.stdout.write('\\x1b[?25h'); process.exit(); }" nl
+                    "var __rgr_k = \"\";" nl
+                    "if (key && key.name) { __rgr_k = key.name; } else if (str && str.length > 0) { __rgr_k = str; } else if (key && key.sequence) { __rgr_k = key.sequence; }" nl
+                    "if (__rgr_k !== \"\") { " (e 1) " = __rgr_k; global.r_key_queue.push(__rgr_k); }" nl
                     (block 2) 
                     i nl "});" nl
                  )
@@ -4519,7 +4569,11 @@ var r_key_queue: [String] = []
 var r_key_queue_lock = NSLock()
 
 func r_setup_raw_mode() {
-    let _ = system(\"stty cbreak min 1 -echo\")
+    let p = Process()
+    p.executableURL = URL(fileURLWithPath: \"/bin/stty\")
+    p.arguments = [\"-F\", \"/dev/tty\", \"cbreak\", \"min\", \"1\", \"-echo\"]
+    try? p.run()
+    p.waitUntilExit()
 }
 
 func r_read_key() -> String? {
@@ -4609,7 +4663,11 @@ func r_read_key() -> String? {
 }
 #else
 func r_setup_raw_mode() {
-    let _ = system(\"stty cbreak min 1 -echo\")
+    let p = Process()
+    p.executableURL = URL(fileURLWithPath: \"/bin/stty\")
+    p.arguments = [\"-F\", \"/dev/tty\", \"cbreak\", \"min\", \"1\", \"-echo\"]
+    try? p.run()
+    p.waitUntilExit()
 }
 
 func r_read_key() -> String? {
@@ -4863,8 +4921,10 @@ std::string r_cpp_str_to_uppercase(std::string original)
                 go ("float64( " (e 1) " )")
                 es6 ( (e 1) )
                 swift3 ("Double(" (e 1) ")")
+                swift6 ("Double(" (e 1) ")")
                 scala ( (e 1) '.toDouble')
                 java7 ("Double.valueOf(" (e 1) ")")
+                kotlin ( (e 1) ".toDouble()" )
                 cpp ("(double)(" (e 1) ")")
                 php ( (e 1) )
                 rust ("(" (e 1) " as f64)")
@@ -5280,6 +5340,79 @@ std::string r_cpp_str_to_uppercase(std::string original)
             }
         }
 
+        ; Process lifecycle operators (distinct from HttpServer start/stop)
+        find_process@(moves@( 1 )) cmdFindProcess:RangerProcessBase@(optional) (path:string) {
+            templates {
+                es6 ( "ProcessNameRegistry.__singleton().findByPath(" (e 1) ")" )
+                kotlin ( "ProcessNameRegistry.__singleton().findByPath(" (e 1) ")" )
+                swift6 ( "ProcessNameRegistry.__singleton().findByPath(" (e 1) ")" )
+                swift3 ( "ProcessNameRegistry.__singleton().findByPath(" (e 1) ")" )
+                * ( "/* find_process not implemented */" )
+            }
+        }
+
+        ; proc_send is lowered in ng_RangerProcessProcSend.rgr (typed handler methods, overload match).
+
+        proc_start@(moves@( 1 )) cmdProcStart:void (proc:RangerProcessBase) {
+            templates {
+                es6 ( "ProcessRuntime.startInstance(" (e 1) ")" )
+                kotlin ( "ProcessRuntime.startInstance(" (e 1) ")" )
+                swift6 ( "ProcessRuntime.startInstance(proc: " (e 1) ")" )
+                swift3 ( "ProcessRuntime.startInstance(proc: " (e 1) ")" )
+                * ( "/* proc_start not implemented */" )
+            }
+        }
+
+        proc_stop@(moves@( 1 )) cmdProcStopInst:void (proc:RangerProcessBase) {
+            templates {
+                es6 ( "ProcessRuntime.stopInstance(" (e 1) ")" )
+                kotlin ( "ProcessRuntime.stopInstance(" (e 1) ")" )
+                swift6 ( "ProcessRuntime.stopInstance(proc: " (e 1) ")" )
+                swift3 ( "ProcessRuntime.stopInstance(proc: " (e 1) ")" )
+                * ( "/* proc_stop instance not implemented */" )
+            }
+        }
+
+        proc_stop@(moves@( 1 )) cmdProcStopProcessId:void (processId:int) {
+            templates {
+                es6 ( "ProcessRuntime.stopByProcessId(" (e 1) ")" )
+                kotlin ( "ProcessRuntime.stopByProcessId(" (e 1) ")" )
+                swift6 ( "ProcessRuntime.stopByProcessId(" (e 1) ")" )
+                swift3 ( "ProcessRuntime.stopByProcessId(" (e 1) ")" )
+                * ( "/* proc_stop processId not implemented */" )
+            }
+        }
+
+        proc_stop@(moves@( 1 )) cmdProcStopClass:void (className:string) {
+            templates {
+                es6 ( "ProcessRuntime.stopByClassName(" (e 1) ")" )
+                kotlin ( "ProcessRuntime.stopByClassName(" (e 1) ")" )
+                swift6 ( "ProcessRuntime.stopByClassName(" (e 1) ")" )
+                swift3 ( "ProcessRuntime.stopByClassName(" (e 1) ")" )
+                * ( "/* proc_stop class not implemented */" )
+            }
+        }
+
+        proc_hibernate@(moves@( 1 )) cmdProcHibernate:string (proc:RangerProcessBase) {
+            templates {
+                es6 ( "ProcessRuntime.hibernateInstance(" (e 1) ")" )
+                kotlin ( "ProcessRuntime.hibernateInstance(" (e 1) ")" )
+                swift6 ( "ProcessRuntime.hibernateInstance(proc: " (e 1) ")" )
+                swift3 ( "ProcessRuntime.hibernateInstance(proc: " (e 1) ")" )
+                * ( "\"\"" )
+            }
+        }
+
+        proc_wakeup@(moves@( 2 )) cmdProcWakeup:void (proc:RangerProcessBase state:string) {
+            templates {
+                es6 ( "ProcessRuntime.wakeupInstance(" (e 1) ", " (e 2) ")" )
+                kotlin ( "ProcessRuntime.wakeupInstance(" (e 1) ", " (e 2) ")" )
+                swift6 ( "ProcessRuntime.wakeupInstance(proc: " (e 1) ", state: " (e 2) ")" )
+                swift3 ( "ProcessRuntime.wakeupInstance(proc: " (e 1) ", state: " (e 2) ")" )
+                * ( "/* proc_wakeup not implemented */" )
+            }
+        }
+
     }
 
 

package/dist/lib/JSON.rgr

@@ -90,10 +90,37 @@ operators {
             java7 ( (e 1) ".isNull( " (e 2) " ) ? null : " (e 1) ".optString(" (e 2) ") " )
             kotlin ( "(if (" (e 1) ".isNull(" (e 2) ")) null else " (e 1) ".optString(" (e 2) "))"
 (create_polyfill "
-typealias JSONObject = org.json.JSONObject
-typealias JSONArray = org.json.JSONArray
-typealias JSONDataObject = org.json.JSONObject
-typealias JSONArrayObject = org.json.JSONArray
+open class JSONObject {
+  protected open val values: MutableMap<String, Any?> = mutableMapOf()
+  open fun isNull(key: String): Boolean = !values.containsKey(key) || values[key] == null
+  open fun optString(key: String): String? = values[key]?.toString()
+  open fun optInt(key: String): Int? = when (val v = values[key]) {
+    is Int -> v
+    is Double -> v.toInt()
+    is String -> v.toIntOrNull()
+    else -> null
+  }
+  open fun optDouble(key: String): Double? = when (val v = values[key]) {
+    is Double -> v
+    is Int -> v.toDouble()
+    is String -> v.toDoubleOrNull()
+    else -> null
+  }
+  open fun optBoolean(key: String): Boolean? = values[key] as? Boolean
+  open fun getJSONObject(key: String): JSONObject? = values[key] as? JSONObject
+  open fun getJSONArray(key: String): JSONArray? = values[key] as? JSONArray
+  open fun put(key: String, value: Any?): JSONObject { values[key] = value; return this }
+  override fun toString(): String = values.toString()
+  constructor(source: String) : this() {}
+  constructor()
+}
+open class JSONArray : ArrayList<Any?>() {
+  open fun length(): Int = size
+  override fun get(index: Int): Any? = if (index in indices) super.get(index) else null
+  override fun toString(): String = joinToString(prefix = \"[\", postfix = \"]\")
+}
+typealias JSONDataObject = JSONObject
+typealias JSONArrayObject = JSONArray
 ")
             )
             go ( "r_get_opt_json_string(" (e 1) ", " (e 2) ")"

package/dist/lib/RangerProcess.rgr

@@ -0,0 +1,304 @@
+
+Import "stdops.rgr"
+
+class RangerProcessBase {
+  def __rangerId:int 0
+  def __rangerParentId:int 0
+  def __rangerTypeId:int 0
+  def __rangerClassName:string ""
+  def __rangerPath:string ""
+  def __rangerStateGeneration:int 0
+  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) {
+      uiHost.notifyPath(__rangerPath)
+    }
+    if (__rangerId != 0) {
+      uiHost.notifyId(__rangerId)
+    }
+  }
+
+  fn __rangerOnDescendantUiChanged:void (child:RangerProcessBase hint:string) {
+    this.markStateDirty()
+    def parent@(optional):RangerProcessBase (__rangerParent)
+    if ((null? parent) == false) {
+      def p:RangerProcessBase (unwrap parent)
+      if (p.__rangerId != 0) {
+        p.__rangerOnDescendantUiChanged(child hint)
+      }
+    }
+  }
+
+  fn __rangerTrackChild:void (child:RangerProcessBase) {
+    push __rangerChildren child
+  }
+
+  fn __rangerClearChildren:void () {
+    def empty:[RangerProcessBase]
+    __rangerChildren = empty
+  }
+
+  fn __rangerInvokeStart:void () {
+  }
+
+  fn __rangerInvokeStop:void () {
+  }
+
+  fn __rangerInvokeHibernate:string () {
+    return ""
+  }
+
+  fn __rangerInvokeWakeup:void (state:string) {
+  }
+
+  fn __rangerStopSubtree:void () {
+  }
+
+  ; Legacy hook; prefer typed proc_send → handler methods on @process classes.
+  fn receiveMessage:void (name:string value:string) {
+  }
+}
+
+; Single app-wide ID space for all @process instances (roots and children).
+class ProcessIdRegistry @singleton(true) {
+  def next:int 1
+
+  fn allocate:int () {
+    def id (this.next)
+    this.next = id + 1
+    return id
+  }
+}
+
+class ProcessNameRegistry @singleton(true) {
+  def byPath:[string:RangerProcessBase]
+
+  fn register:void (path:string proc:RangerProcessBase) {
+    if ((strlen path) == 0) {
+      return
+    }
+    if (proc.__rangerId == 0) {
+      return
+    }
+    def existing@(optional):RangerProcessBase (get byPath path)
+    if ((null? existing) == false) {
+      def old:RangerProcessBase (unwrap existing)
+      if (old.__rangerId != 0 && old.__rangerId != proc.__rangerId) {
+        print ("ERROR: duplicate live @name process path: " + path)
+        return
+      }
+    }
+    set byPath path proc
+  }
+
+  fn unregister:void (path:string) {
+    ; Map entry may remain until overwritten; hasLive/findByPath check __rangerId.
+  }
+
+  fn findByPath@(optional):RangerProcessBase (path:string) {
+    return (get byPath path)
+  }
+
+  fn hasLive:boolean (path:string) {
+    def found@(optional):RangerProcessBase (get byPath path)
+    if (null? found) {
+      return false
+    }
+    def inst:RangerProcessBase (unwrap found)
+    if (inst.__rangerId == 0) {
+      return false
+    }
+    return true
+  }
+
+  fn unbindIfConfigured:void (proc:RangerProcessBase) {
+    if ((strlen proc.__rangerPath) > 0) {
+      this.unregister(proc.__rangerPath)
+      proc.__rangerPath = ""
+    }
+  }
+}
+
+; 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) {
+  }
+
+  fn notifyId:void (processId:int) {
+  }
+}
+
+class ProcessRuntime @singleton(true) {
+
+  sfn stopInstance:void (proc:RangerProcessBase) {
+    ProcessNameRegistry.__singleton().unbindIfConfigured(proc)
+    proc.__rangerStopSubtree()
+  }
+
+  sfn startInstance:void (proc:RangerProcessBase) {
+    ProcessNameRegistry.__singleton().bindIfConfigured(proc)
+    proc.__rangerInvokeStart()
+  }
+
+  sfn hibernateInstance:string (proc:RangerProcessBase) {
+    def res:string (proc.__rangerInvokeHibernate())
+    return res
+  }
+
+  sfn wakeupInstance:void (proc:RangerProcessBase state:string) {
+    proc.__rangerInvokeWakeup(state)
+  }
+}
+
+class RangerFieldDescriptor {
+  def name:string ""
+  def typeName:string ""
+  def isOptional:boolean false
+}
+
+class RangerClassDescriptor {
+  def className:string ""
+  def fields:[RangerFieldDescriptor]
+}
+
+; CLI tree renderer for @process hierarchies (__rangerChildren). Root list:
+; ProcessRuntime.collectAllLiveRoots() (generated when the app has @process classes).
+class ProcessTreeView {
+  def showParentId:boolean true
+
+  fn isLive:boolean (proc:RangerProcessBase) {
+    if (proc.__rangerId == 0) {
+      return false
+    }
+    return true
+  }
+
+  fn nodeLabel:string (proc:RangerProcessBase) {
+    def label:string ""
+    label = proc.__rangerClassName
+    label = label + " #"
+    label = label + (to_string proc.__rangerId)
+    if (showParentId) {
+      label = label + " parent="
+      label = label + (to_string proc.__rangerParentId)
+    }
+    return label
+  }
+
+  fn countLiveChildren:int (proc:RangerProcessBase) {
+    def n:int 0
+    for proc.__rangerChildren ch:RangerProcessBase i {
+      if (this.isLive(ch)) {
+        n = n + 1
+      }
+    }
+    return n
+  }
+
+  fn renderSubtree:void (proc:RangerProcessBase indent:string) {
+    def liveIdx:int 0
+    def total:int (this.countLiveChildren(proc))
+    for proc.__rangerChildren ch:RangerProcessBase i {
+      if ((this.isLive(ch)) == false) {
+        continue
+      }
+      def branch:string "|-> "
+      def childIndent:string "    "
+      if (liveIdx == (total - 1)) {
+        branch = "L-> "
+      }
+      def line:string ""
+      line = indent + branch
+      def nodeText:string (this.nodeLabel(ch))
+      line = line + nodeText
+      print line
+      def nextIndent:string ""
+      nextIndent = indent + childIndent
+      this.renderSubtree(ch nextIndent)
+      liveIdx = liveIdx + 1
+    }
+  }
+
+  fn countLiveRoots:int (roots:[RangerProcessBase]) {
+    def c:int 0
+    for roots r:RangerProcessBase i {
+      if (this.isLive(r)) {
+        c = c + 1
+      }
+    }
+    return c
+  }
+
+  fn renderRoots:void (roots:[RangerProcessBase] title:string) {
+    print ""
+    if (title != "") {
+      print title
+    } {
+      print "Process tree"
+    }
+    def n:int (size roots)
+    if (n == 0) {
+      print "  (no live root processes)"
+      return
+    }
+    def liveTotal:int (this.countLiveRoots(roots))
+    if (liveTotal == 0) {
+      print "  (no live root processes)"
+      return
+    }
+    def shown:int 0
+    def i:int 0
+    while (i < n) {
+      def root:RangerProcessBase (at roots i)
+      if (this.isLive(root)) {
+        def branch:string "|-> "
+        def childIndent:string "    "
+        if (shown == (liveTotal - 1)) {
+          branch = "L-> "
+        }
+        def line:string ""
+        line = "  " + branch
+        def rootText:string (this.nodeLabel(root))
+        line = line + rootText
+        print line
+        this.renderSubtree(root childIndent)
+        shown = shown + 1
+      }
+      i = i + 1
+    }
+  }
+}