@naanlang/naan 1.5.0 → 1.7.0

package/frameworks/service/model.nlg

@@ -0,0 +1,71 @@
+/*
+ * model.nlg
+ * Naanlib/frameworks/service
+ *
+ * Naan service model.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2023-2026 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * ServiceModel
+ *
+ * Model object for services, such as instance management. This is used to conceal architectural
+ * details from service users.
+ *
+ */
+
+closure ServiceModel(local model) {
+    global()
+    model = new(object, this)
+    model@\.class = new(object)
+
+    // add
+    //
+    // Add a location to our model with the specified name.
+    //
+    model@\.class.add = function add(name, local node) {
+        if !string(name) || name.trim() == ""
+            throw("ServiceModel.add: invalid name")
+        node = new(object)
+        node.id = name
+        node.parent = self
+        node@\.parent = self
+        self[name] = node
+        node
+    }
+    
+    // children
+    //
+    // List the ids of the children of the specified location, which is false for the root.
+    //
+    model@\.class.children = function children(parent) {
+        self.*.toarray.filter(function(id) { !id.startsWith(".") })
+    }
+
+    // finis
+
+    model
+};
+
+
+/*
+ * modelInit
+ *
+ * Initialize the component.
+ *
+ */
+
+function modelInit(local manifest) {
+    manifest = `(ServiceModel, modelInit)
+
+    Naan.module.build(module.id, "model", function(modobj, compobj) {
+        require("./service.nlg")
+        compobj.manifest = manifest
+        modobj.exports.ServiceModel = ServiceModel
+    })
+} ();

package/frameworks/service/nubnode.nlg

@@ -0,0 +1,136 @@
+/*
+ * nubnode.nlg
+ * Naanlib/frameworks/service
+ *
+ * Nub for node worker access to IMP.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2026 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * NodeWorkerNub
+ *
+ * NodeWorkerNub provides an IMP interface that runs on node workers. This allows the worker to
+ * communicate with the IMP network and the main thread. The worker IMP must be created before this.
+ *
+ */
+
+closure NodeWorkerNub(imp, options, local nownub) {
+    global(App,js)
+    if App.workerNub
+        return (App.workerNub)                                              // singleton
+
+    options = merge({
+        name: "NodeWorkerNub"
+        type: "node-worker-nub"
+    }, options)
+    nownub = new(object, this)
+    nownub.instanceID = imp.us.instanceID || UUID()
+    nownub.dispatcher = require("naanlib:frameworks/running/taskexec.nlg").TaskDispatcher(false, false, "NodeWorkerNub")
+
+    // impReceive
+    //
+    // Receive a remote request and reply to it.
+    //
+    nownub.impReceive = closure impReceive(message, sourceID) {
+        if message.id == "targetin"
+            nownub.dispatcher(message.data, function(reply) {
+                nownub.sender(sourceID, {
+                    id: "targetout",
+                    data: reply
+                })
+            })
+    }
+
+    // impUnknown
+    //
+    // Received an unknown destination notice from the other side.
+    //
+    nownub.impUnknown = function impUnknown(unknownID, sourceID, gateway) {
+        if !gateway
+            debuglog("NodeWorkerNub.impUnknownID:", unknownID, "sourceID:", sourceID)
+    }
+
+    // mainContext
+    //
+    // Convenience method to get the main thread and its remote context.
+    //
+    nownub.mainContext = function mainContext(local error, mtx, ctx) {
+        if !(mtx = nownub.mtx) {
+            `(error, mtx) = require("../running/remote_req.nlg").MainThread()
+            if error
+                return (list(error))
+            nownub.mtx = mtx
+        }
+        `(error, ctx) = mtx.context()
+        if error
+            list(error)
+        else
+            list(false, ctx, mtx)
+    }
+
+    // execProxy
+    //
+    // Get a proxy object for our executor on the main thread.
+    //
+    nownub.execProxy = closure execProxy(error, ctx, execID, exec) {
+        `(error, ctx) = mainContext()
+        if !error
+            `(error, execID) = ctx.eval(subatq(App.imp.pipes.destID.info.ourID, [list(`destID, nownub.instanceID)]))
+        if !error
+            `(error, exec) = ctx.eval(subatq(App.imp.direct.execID.obj, [list(`execID, execID)]))
+        list(error, exec)
+    }
+
+    // message event
+    //
+    // Incoming data.
+    //
+    js.t.msgPort.on("message", function(msg) {
+        if msg.id == "naan-imp-node"
+            nownub.impconn.dispatch(new(msg.data))
+    })
+
+    // register our connects *after* the receivers are configured above
+
+    nownub.sender = imp.register(nownub, {
+        name: options.name
+        type: options.type
+        meta: options.meta || undefined
+        instanceID: nownub.instanceID
+        services: [ "naan-node-worker" ]
+    })
+    nownub.impconn = imp.requester(function(data) {
+        js.t.msgPort.postMessage({                                          // send to main
+            id: "naan-imp-node",
+            data: data
+        })
+        list(false, { sent: true })
+    })
+
+    // finis
+
+    App.workerNub = nownub
+};
+
+
+/*
+ * nubnoInit
+ *
+ * Initialize the component.
+ *
+ */
+
+function nubnoInit(local manifest) {
+    manifest = `(NodeWorkerNub, nubnoInit)
+
+    Naan.module.build(module.id, "nubnode", function(modobj, compobj) {
+        require("./service.nlg")
+        compobj.manifest = manifest
+        modobj.exports.NodeWorkerNub = NodeWorkerNub
+    })
+} ();

package/frameworks/service/nubweb.nlg

@@ -0,0 +1,124 @@
+/*
+ * nubweb.nlg
+ * Naanlib/frameworks/service
+ *
+ * Nub for web worker access to IMP.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2026 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * WebWorkerNub
+ *
+ * WebWorkerNub provides an IMP interface that runs on web workers. This allows the worker to
+ * communicate with the IMP network and the main thread. The worker IMP must be created before this.
+ *
+ */
+
+closure WebWorkerNub(imp, options, local wonub) {
+    global(App,js)
+    if App.workerNub
+        return (App.workerNub)                                              // singleton
+
+    options = merge({
+        name: "WebWorkerNub"
+        type: "web-worker-nub"
+    }, options)
+    wonub = new(object, this)
+    wonub.instanceID = imp.us.instanceID || UUID()
+    wonub.dispatcher = require("naanlib:frameworks/running/taskexec.nlg").TaskDispatcher(false, false, "WebWorkerNub")
+
+    // impReceive
+    //
+    // Receive a remote request and reply to it.
+    //
+    wonub.impReceive = closure impReceive(message, sourceID) {
+        if message.id == "targetin"
+            wonub.dispatcher(message.data, function(reply) {
+                wonub.sender(sourceID, {
+                    id: "targetout",
+                    data: reply
+                })
+            })
+    }
+
+    // impUnknown
+    //
+    // Received an unknown destination notice from the other side.
+    //
+    wonub.impUnknown = function impUnknown(unknownID, sourceID, gateway) {
+        if !gateway
+            debuglog("WebWorkerNub.impUnknownID:", unknownID, "sourceID:", sourceID)
+    }
+
+    // mainContext
+    //
+    // Convenience method to get the main thread and its remote context.
+    //
+    wonub.mainContext = function mainContext(local error, mtx, ctx) {
+        if !(mtx = wonub.mtx) {
+            `(error, mtx) = require("../running/remote_req.nlg").MainThread()
+            if error
+                return (list(error))
+            wonub.mtx = mtx
+        }
+        `(error, ctx) = mtx.context()
+        if error
+            list(error)
+        else
+            list(false, ctx, mtx)
+    }
+
+    // message event
+    //
+    // Incoming data.
+    //
+    js.w.addEventListener("message", function message(e, local msg) {
+        msg = new(e.data)
+        if msg.scope == "naan-imp-web"
+            wonub.impconn.dispatch(msg.data)
+    })
+
+    // register our connects *after* the receivers are configured above
+
+    wonub.sender = imp.register(wonub, {
+        name: options.name
+        type: options.type
+        meta: options.meta || undefined
+        instanceID: wonub.instanceID
+        services: [ "naan-web-worker" ]
+    })
+    wonub.impconn = imp.requester(function(data) {
+        js.w.postMessage({                                                  // send to main
+            scope: "naan-imp-web",
+            data: data
+        })
+        list(false, { sent: true })
+    })
+
+    // finis
+
+    App.workerNub = wonub
+};
+
+
+/*
+ * nubweInit
+ *
+ * Initialize the component.
+ *
+ */
+
+function nubweInit(local manifest) {
+    manifest = `(WebWorkerNub, nubweInit)
+
+    Naan.module.build(module.id, "nubweb", function(modobj, compobj) {
+        require("./service.nlg")
+        compobj.manifest = manifest
+        modobj.exports.WebWorkerNub = WebWorkerNub
+    })
+} ();

package/frameworks/service/service.nlg

@@ -0,0 +1,28 @@
+/*
+ * service.nlg
+ * Naanlib/frameworks/service
+ *
+ *     Root component for services functionality.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2026 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * svcInit
+ *
+ * Initialize the service module.
+ *
+ */
+
+function svcInit(local manifest) {
+    manifest = `(svcInit)
+
+    Naan.module.build(module.id, "service", function(modobj, compobj) {
+        require("../common/common.nlg").LiveImport()
+        compobj.manifest = manifest
+    })
+} ();

package/frameworks/storage/file_manager.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2020-2024 by Richard C. Zulch
+ * Copyright (c) 2020-2026 by Richard C. Zulch
  *
  */
 
@@ -31,6 +31,7 @@ closure FileManager(fs, options, local files, watch, opqueue, willgit, hadgit) {
     watch = commonWatching.Watchable()
     files.watch = watch.watch                                               // watch for file changes
     files.unWatch = watch.unwatch                                           // stop watching for file changes
+    hadgit = { }
 
     // compareNodes
     //
@@ -460,7 +461,7 @@ closure FileManager(fs, options, local files, watch, opqueue, willgit, hadgit) {
                 unknownFiles = []
                 unknownFileStatus = {}
                 delgit = hadgit
-                hadgit = {}
+                hadgit = { }
                 willgit = false
                 for item in statlist {
                     hadgit[item.path] = 1