@moskva/runtime 0.1.0

package/IRunnable.js

@@ -0,0 +1,11 @@
+export class IRunnable {
+ /**
+  * Execute an operation
+  * @param {!Function} op
+  * @param {...object} params
+  */
+ run(op, ...params){
+  //
+ }
+} // in normal js, not possible to invoke the class without new operator,
+// in the advanced JavaScript it'd be possible to invoke interface directly.

package/changes.md

@@ -0,0 +1,6 @@
+## 27 jan 2026
+
+### 0.1.0
+
+- releae the first virstion that exports _Runnable_ functional interface with
+  test.

package/index.js

@@ -0,0 +1,14 @@
+var { FnImplFactory } = require('@javish/lib')
+
+module.exports.Runnable=FnImplFactory(
+ class Runnable {
+  __fm() {
+   return this.run
+  }
+ /** Run an operation */
+ run() {}
+}, ({
+ run() {
+  console.warn('[run] not implemented')
+ }
+}))

package/lib/Test.js

@@ -0,0 +1,18 @@
+var { FnImplFactory } = require('@javish/lib')
+
+var RunnableTest = FnImplFactory(
+ class RunnableTest {
+  __fm() {
+   return this.run
+  }
+ /** The test list @type {string[]} */
+ test = []
+ /** Run an operation */
+ run() {}
+}, ({
+ run() {
+  console.warn('[run] not implemented for test')
+ }
+}))
+
+module.exports = RunnableTest

package/lib/index.js

@@ -0,0 +1 @@
+module.exports.Runnable=require('./Test')

package/package.json

@@ -0,0 +1,4 @@
+{
+ "name": "@moskva/runtime",
+ "version": "0.1.0"
+}

package/readme.md

@@ -0,0 +1,89 @@
+# Runtime Moskva
+
+This runtime provides callable instances of `Runnable` functional interfaces. A
+`Runnable` is a class instance that can be invoked like a function.
+
+```js
+interface IRunnable {
+ run() {}
+}
+```
+
+<!-- Instances are allocated memory and can request compute via the event loop. -->
+
+## Usage
+
+An example below shows that even though `runner` is an instance, it can still be
+invoked as a function:
+
+```js
+var{Runnable}=require('@moskva/runtime')
+
+var runner=new class extends Runnable {
+ const(){
+  this.test=[]
+  this.test.push(new Date)
+ }
+ test2(){
+  return this.test
+ }
+ run(){
+  console.log(' < Hello runner; test =',this.test2())
+ }
+}
+
+console.log('calling runner:')
+runner()
+```
+
+```sh
+created new functional [class Runnable]
+calling runner:
+ < Hello runner; test = [ 2026-01-27T23:19:34.106Z ]
+```
+
+---
+
+```js
+var runner2 = new class extends Runnable {
+ // can't use fieldss / constructor
+ // new_field = []
+ const() {
+  this.test=['test']
+ }
+ run() {
+  console.log(' < Hello runner2; test =',this.test)
+ }
+}
+
+console.log('calling runner2:')
+runner2()
+```
+```sh
+calling runner2:
+ < Hello runner2; test = [ 'test' ]
+```
+
+Instances of standard, non-runnable classes cannot be invoked. This behaviour is
+only available when extending `Runnable`.
+
+## Implementation requirements
+
+* The `run` method **must** be implemented. It is the entry point invoked when
+  the instance is called.
+* The implementation can access additional internal APIs via `this`.
+
+## Initialisation rules
+
+Instance fields must be initialised inside the `const` method.
+
+Class field syntax is not supported. The implementation relies on a proxy, and
+constructing a `Runnable` with field initialisers would cause infinite
+recursion. There is currently no safe way to intercept or extract field
+initialisers.
+
+Unless a viable solution is found, this limitation will remain.
+
+---
+
+(c) 2026

package/readme0.md

@@ -0,0 +1,56 @@
+# Runtime Moskva
+
+This runtime is the creation of instances of _Runnable_ functional interfaces,
+i.e., classes that can be run as functions directly.
+
+ <!-- that are
+allocated some memory and can request compute via the event loop. -->
+
+```js
+interface IRunnable {
+ run() {}
+}
+```
+
+<!--
+It can run those in isolates, i.e., threads on the same process that share
+access to host AOT memory. -->
+
+## Usage
+
+For example, even if the new _RunnerExt_ is an instance, it can still be run a
+function as shown below:
+
+
+```js
+var{Runnable}=require('@moskva/runtime')
+
+var runner = new class runner extends Runnable {
+ const() {
+  this.test.push(new Date)
+ }
+ test2() {
+  return this.test
+ }
+ run() {
+  console.log(' < Hello runner ext; test =',this.test2())
+ }
+}
+
+console.log('calling runner ext:')
+runner()
+```
+
+Instances of standard, non-runnable classes cannot be invoked, unlike when using
+the Runnable superclass.
+
+Implementation requirements: implement the `run` method that will be invoked
+while the impementation can access additional `this` apis internally.
+
+To initialise the instance variables (fields), they must be instantiated in
+const method, as the fields syntax won't work as the solution is based on proxy
+and attempting to construct a Runnable would create an infinite recursion and
+there's no way to get handle of field initialisers. Unless one is found this
+won't change.
+
+---

package/test/index.js

@@ -0,0 +1,31 @@
+var {Runnable} = require('..')
+
+var runner = new class extends Runnable {
+ const() {
+  this.test=[]
+  this.test.push(new Date)
+ }
+ test2() {
+  return this.test
+ }
+ run() {
+  // it needs to have this of the runner also
+  console.log(' < Hello runner; test =',this.test2())
+ }
+}
+
+console.log('calling runner:')
+runner()
+
+var runner2 = new class extends Runnable {
+ const() {
+  this.test=['test']
+ }
+ run() {
+  // it needs to have this of the runner also
+  console.log(' < Hello runner2; test =',this.test)
+ }
+}
+
+console.log('calling runner2:')
+runner2()