@naanlang/naan 1.7.0 → 1.7.2

package/frameworks/client/apiclient.nlg

@@ -208,6 +208,7 @@ closure APIClient(imp, options, local client, url, guid) {
 closure WebSocketClient(options, imp, local wesc, ws, pending) {
     global(js)
     wesc = new(object, this)
+    
 
     // reconnect
     //
@@ -226,40 +227,29 @@ closure WebSocketClient(options, imp, local wesc, ws, pending) {
     //
     // Establish a websocket connection with the host.
     //
-    wesc.connect = closure connect(local url, result) {
+    wesc.connect = closure connect(local url, result, error) {
         if ws {
             if pending
                 return (pending.wait())                                     // connect in process
             if !wesc.fatal
                 return(list(false, { connected: true }))                    // already open
         }
-        try {
-            url = xnew(js.w.URL, options.url)
-        } catch {
-            return(list(Error("invalid URL ${options.url}", exception)))
-        }
-        if url.protocol == "https:"
-            url.protocol = "wss:"
-        else
-            url.protocol = "ws:"
-        ws = xnew(js.w.WebSocket, url.href)
-        if wesc.fatal
-            debuglog("WebSocketClient reopen")                              // ### not pretty to see this
-        wesc.fatal = false
-        pending = new(nonce)
 
         // onopen
         // The WebSocket connection is now open.
-        ws.onopen = function onopen(e) {
+        function onopen(e) {
             if wesc.impconn {
                 result = wesc.impconn.reopen()
                 pending.signal(result)
                 return
             }
-            wesc.impconn = imp.requester(function(data) {
+            wesc.impconn = imp.requester(function(data, local error, text) {
                 if !pending && reconnect()                                  // !pending means not opening/reopening
                     return                                                  // failed to reconnect
-                ws.send(js.w.JSON.stringify(data))
+                `(error, text) = JsonStringify(data)
+                if error
+                    return (list(error))
+                ws.send(text)
                 list(false, { sent: true })
             }, {
                 secret: options.guid
@@ -274,7 +264,7 @@ closure WebSocketClient(options, imp, local wesc, ws, pending) {
 
         // onmessage
         // A message was received via WebSockets.
-        ws.onmessage = function onmessage(e, local error, message) {
+        function onmessage(e, local error, message) {
             `(error, message) = JsonParse(e.data)
             if !error {
                 message = new(message)
@@ -289,7 +279,7 @@ closure WebSocketClient(options, imp, local wesc, ws, pending) {
         // onerror
         // An error occurred on the WebSocket connection.
         // This can happen in normal operation when the connection times out.
-        ws.onerror = function onerror(e) {
+        function onerror(e) {
             if !wesc.fatal
                 wesc.fatal = Error("websocket failed", e)
             pending.signal(list(wesc.fatal))
@@ -298,7 +288,7 @@ closure WebSocketClient(options, imp, local wesc, ws, pending) {
         
         // onclose
         // The WebSocket connection was closed.
-        ws.onclose = function onclose(e) {
+        function onclose(e) {
             // if e.code != 1000 && e.code != 1001 && e.code != 1005 && e.code != 1006
                 debuglog("WebSocketClient: closed:", e.code, e.reason)      // ### not pretty to see this
             ws = false
@@ -308,6 +298,19 @@ closure WebSocketClient(options, imp, local wesc, ws, pending) {
             pending = false
         }
 
+        `(error, ws) = call(clirWebsocket(), options.url, {
+            onopen: onopen.proc
+            onmessage: onmessage.proc
+            onerror: onerror.proc
+            onclose: onclose.proc
+        })
+        if error
+            return (list(wesc.fatal = error))                               // failed to even get started
+
+        if wesc.fatal
+            debuglog("WebSocketClient reopen")                              // ### not pretty to see this
+        wesc.fatal = false
+        pending = new(nonce)
         result = pending.wait(10000, list(Error("IMP connection timeout")))
         pending = false
         result

package/frameworks/client/client.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2020-2025 by Richard C. Zulch
+ * Copyright (c) 2020-2026 by Richard C. Zulch
  *
  */
 
@@ -31,6 +31,26 @@ function clirRequester() {
 };
 
 
+/*
+ * clirWebsocket
+ *
+ *     Return an appropriate Websocket client based on our environment.
+ *
+ */
+
+clirWebsocketApi = false;
+
+function clirWebsocket() {
+    if !clirWebsocketApi {
+        if js.w
+            clirWebsocketApi = require("naanlib:frameworks/browser/ws_client.nlg").WebSocket
+        else
+            clirWebsocketApi = require("naanlib:frameworks/node/ws_client.nlg").WebSocket
+    }
+    clirWebsocketApi
+};
+
+
 /*
  * clirInit
  *
@@ -40,7 +60,7 @@ function clirRequester() {
  */
 
 function clirInit(local manifest) {
-    manifest = `(clirRequester, clirInit)
+    manifest = `(clirRequester, clirWebsocket, clirInit)
 
     Naan.module.build(module.id, "client", function(modobj, compobj) {
         require("../common/").LiveImport()

package/frameworks/client/relaycon.nlg

@@ -52,7 +52,7 @@ closure RelayCon(imp, options, local relay, nlregex)
         serverID: "Workers"
         workerID: "NideServer"
     }, options.config)
-    relay.instanceID = UUID()
+    relay.instanceID = imp.getUUID("RelayCon(${options.name}) instanceID")
     relay.exec = execsMod.ExecutorBase(false, "Host", options.name)
     nlregex = RegExp("\\n", "g")
 

package/frameworks/common/common.nlg

@@ -252,14 +252,16 @@ macro LiveExport() {
         importList = []
         //
         // LiveImport
-        // Return a new LiveImport function to be exported by the module who called MakeLiveImport.
+        // Return a new LiveImport function to be exported by the module who called LiveExport.
         //
-        macro LiveImport(fixproc, local importingMod, mdex, updater) {
+        macro LiveImport(fixproc, local importingMod, item, updater) {
             importingMod = car(nsrights().lookup("module"))
-            mdex = importList.indexOf(importingMod)
-            if mdex >= 0
-                updater = importList[mdex]                                  // already registered
-            else {
+            for item in importList
+                if item.proc.1.namespace === importingMod.namespace {
+                    updater = item
+                    break
+                }
+            if !updater {
                 updater = closure(importingMod, fixproc) {                  // create new updater
                     putproc(compress(updateImports), function updateImports(local goback) {
                         if importingMod !== exporterMod {
@@ -269,10 +271,10 @@ macro LiveExport() {
                         try {
                             call(fixproc, exporterMod)                      // let caller do any fixups
                         } catch {
-                            if (true)
-                                debuglog("LiveImport fixup failed in", nsrights(), "exception:", exception)
+                            debuglog("LiveImport fixup failed in", nsrights(), "exception:", exception)
+                        } finally {
+                            goback()
                         }
-                        goback()
                     })
                     updateImports
                 } (importingMod, eval(fixproc))

package/frameworks/node/apiserver.nlg

@@ -44,7 +44,7 @@ closure APIServer(options, local server, chroot) {
     server.guid = options.guid
     server.notifyq = []
     server.responseq = []
-    server.instanceID = UUID()
+    server.instanceID = App.imp.getUUID("APIServer instanceID")
     options = merge({
         relpath: ""
         name: "NaanServer"

package/frameworks/node/worker.nlg

@@ -44,7 +44,7 @@ closure CurBot(options, local curbot) {
     curbot.guid = 1
     curbot.host = js.t                                                      // our magic Naan controller reference
 
-    curbot.instanceID = UUID()
+    curbot.instanceID = App.imp.getUUID("CurBot(${options.name}) instanceID")
     curbot.sender = App.imp.register(curbot, {
         name: curbot.name
         type: curbot.type
@@ -266,7 +266,7 @@ closure NowBot(options, local nowbot, nodeops, subChannel, ptySpawned) {
     nowbot.thread.postMessage({ hereIsYourPort: subChannel.port1 }, [subChannel.port1])
     nowbot.msgport = subChannel.port2
 
-    nowbot.instanceID = UUID()
+    nowbot.instanceID = App.imp.getUUID("NowBot(${options.name}) instanceID")
     nowbot.sender = App.imp.register(nowbot, {
         name: options.name
         type: options.type
@@ -428,6 +428,16 @@ closure NowBot(options, local nowbot, nodeops, subChannel, ptySpawned) {
         nowbot.thread = false
         destroy()
     })
+    
+    // close
+    //
+    // Close and remove our IMP resources, but leave the worker alone.
+    //
+    nowbot.close = function close() {
+        nowbot.impconn.destroy()
+        nowbot.impconn = false
+        App.imp.unregister(nowbot.instanceID)
+    }
 
     // destroy
     //
@@ -436,9 +446,7 @@ closure NowBot(options, local nowbot, nodeops, subChannel, ptySpawned) {
     nowbot.destroy = function destroy() {
         terminate()
         nowbot.thread = false
-        nowbot.impconn.destroy()
-        nowbot.impconn = false
-        App.imp.unregister(nowbot.instanceID)
+        close()
     }
 
     // NaaN message
@@ -446,7 +454,7 @@ closure NowBot(options, local nowbot, nodeops, subChannel, ptySpawned) {
     // A message has been received from NaaN running on the worker thread.
     //
     nowbot.msgport.on("message", function (msg, local startmsg) {
-        if msg.id == "naan-imp-node" {
+        if msg.id == "naan-imp-out" {
             nowbot.impconn.dispatch(new(msg.data))
             return
         } else if msg.id == "loaded" {
@@ -542,7 +550,7 @@ closure NobBot(options, local nobbot)
 
     nobbot.impconn = App.imp.responder(function(data) {
         nobbot.msgport.postMessage({                                        // send to worker
-            id: "naan-imp-node"                                             // scoped for NodeWorkerNub
+            id: "naan-imp-in"                                               // scoped for NodeWorkerNub
             data: data
         })
         list(false, { sent: true })

package/frameworks/node/ws_client.nlg

@@ -13,106 +13,47 @@
 /*
  * WebSocket
  *
- * Create a WebSocket client connection object.
+ * Create a WebSocket client connection object, returning a tuple.
  *
  * Required:
- *      host:       <string>                    // host:port
+ *      urlstr:     <string>
  *
  * Options:
  *  {
  *      wss:        <boolean>                   // true to use secure connection
+ *      query:      <string>                    // query string starting with ?
  *      onopen:     <proc>(e)                   // connection has opened
  *      onmessage:  <proc>(e, message)          // message received
  *      onerror:    <proc>(e)                   // error occurred
  *      onclose:    <proc>(e)                   // connection has closed
- *      query:      <string>                    // query string starting with ? for insecure connections
- *      querys:     <string>                    // query string starting with ? for secure connections
  *  }
  *
  */
 
-closure WebSocket(host, options, local wsock) {
-    global(js)
-    wsock = new(object, this)
-    options = new(options) || { }
+closure WebSocket(urlstr, options, local error, wslib, url, ws) {
+    `(error, wslib) = await(js.i("ws"))
+    if error
+        return (list(error))
 
-    // connect
-    //
-    // Connect with the host if not already connected, returning a result tuple.
-    //
-    wsock.connect = closure connect(local error, ws, url, pending) {
-        if wsock.ws
-            return (list(false, { open: true }))
-        `(error, ws) = await(js.i("ws"))
-        if error
-            return (list(error))
-        if options.wss
-            url = "wss://${host}${options.querys||''}"
-        else
-            url = "ws://${host}${options.query||''}"
-        wsock.ws = xnew(ws.default, url)
-        pending = new(nonce)
-
-        // onopen
-        // The WebSocket connection is now open.
-        wsock.ws.onopen = closure onopen(e) {
-            pending.signal(list(false, { ok: true }))
-            options.onopen(e, e.target, e.type)
-        }
-
-        // onmessage
-        // A message was received from the worker via WebSockets.
-        wsock.ws.onmessage = closure onmessage(e, local message) {
-            try {
-                message = new(JSONparse(e.data))
-            } catch {
-                debuglog("can't decode incoming ws message:", exception)
-                options.onerror(Error("can't decode incoming message:", exception))
-                return
-            }
-            options.onmessage(e, message)
-        }
-
-        // onerror
-        // An error occurred on the WebSocket connection.
-        wsock.ws.onerror = closure onerror(e, local error) {
-            error = Error("websocket failed", e)
-            options.onerror(e, error)
-            pending.signal(list(error))                                     // ensure connect completes
-        }
-
-        // onclose
-        // The WebSocket connection was closed.
-        wsock.ws.onclose = closure onclose(e) {
-            options.onclose(e, e.code, e.reason)
-            pending.signal(list(Error("connection closed")))                // ensure connect completes
-            wsock.ws = false
-        }
-
-        pending.wait()
+    try {
+        url = xnew(js.g.URL, urlstr)
+    } catch {
+        return (list(Error("invalid URL ${urlstr}", exception)))
     }
-
-    // send
-    //
-    //     Send a message dictionary.
-    //
-    wsock.send = function send(message) {
-        wsock.ws.send(JSONstringify(message))
-    }
-
-    // close
-    //
-    //     Close the connection.
-    //
-    wsock.close = function close(reason) {
-        if !reason
-            reason = 1000                                                   // normal close
-        wsock.ws.close(reason)
-    }
-
-    // finis
-
-    wsock
+    options = merge({
+        query: url.search || ''
+        wss: url.protocol == "https:"
+    }, options)
+    if options.wss
+        url = "wss://${url.host}${options.query}"
+    else
+        url = "ws://${url.host}${options.query}"
+    ws = xnew(wslib.default, url)
+    ws.onopen = options.onopen
+    ws.onmessage = options.onmessage
+    ws.onerror = options.onerror
+    ws.onclose = options.onclose
+    list(false, ws)
 };
 
 

package/frameworks/project/build.nlg

@@ -304,18 +304,26 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
     //
     // Apply substitutions from readSubstitutionFile to string, returning a tuple of the resulting
     // text and the number of substitution patterns actually used from the supplied dictionary.
-    //
-    function applySubstitutions(text, subs, local subbed) {
-        subbed = { }
-        list(text.replace(RegExp("[$][^$\\s]+[$]", "g"), function(match, local subst) {
-            subst = subs[match.slice(1,-1)]
-            if subst {
-                subbed[match] = true
-                subst
-            }
-            else
-                match
-        }), length(subbed))
+    // Specify iterative to repeat the substitution on the result until no more substitutions occur.
+    //
+    function applySubstitutions(text, subs, iterative, local count, subbed) {
+        count = 0
+        loop {
+            subbed = { }
+            text = text.replace(RegExp("[$][^$\\s]+[$]", "g"), function(match, local subst) {
+                subst = subs[match.slice(1,-1)]
+                if subst {
+                    subbed[match] = true
+                    subst
+                }
+                else
+                    match
+            })
+            count += length(subbed)
+            if length(subbed) == 0 || !iterative
+                break
+        }
+        list(text, count)
     }
     
     //
@@ -418,6 +426,16 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
         result
     }
 
+    //
+    // init1
+    //
+    // Initialize a build worker.
+    //
+
+    function init1() {
+        require("../common").LiveImport()
+    }
+
     //
     // parseAndPack1
     //
@@ -426,7 +444,8 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
     // autoquoted to itself, a symbol. This can be used to detect build time vs. runtime.
     
     function parseAndPack1(text, fpath, options, operation,
-        local util, lib, penv, naansym, dlogsym, pmod, pcomp, ournn, output, textout, annerror, annotations, package)
+        local util, lib, modid, penv, naansym, dlogsym, pmod, pcomp, ournn,
+            output, textout, annotations, package)
     {
         //
         // textline
@@ -445,6 +464,7 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
         lib = Naan.module.modlist().Lib.exports
         if !util || !lib
             return (list("Build packager cannot access support functions"))
+        modid = JSpath.basename(JSpath.dirname(fpath))
         //
         // The following crazy rigmarole is about customizing the ParsEnvironment so we can glean
         // enough information to build a package without actually executing the code. To do this we
@@ -461,7 +481,7 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
         pcomp = { }                                                         // our component object
         ournn.module = {
             build: function(modname, compname, proc) {
-                pmod.id = module.id
+                pmod.id = modid
                 pmod.exports = { }
                 pcomp.name = compname
                 call(proc, pmod, pcomp)                                     // obtain manifest
@@ -505,23 +525,39 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
         //
         textout = ""
         try {
-            if !pcomp.name
-                annerror = "Component required to build package"
-            else if output.errors.length > 0
-                annerror = output.errors[0]
-            annotations = output.annotations
-            if annotations {
-                if annotations.length == 0 {                                // empty annotations list
-                    if annerror
-                        annotations = [{                                    // first error becomes annotation
-                            row: 0
-                            column: 0
-                            text: annerror
-                            type: "error"
-                        }]
-                    else
-                        annotations = false }                               // no errors or annotations
+            if output.annotations.length == 0 && output.errors.length == 0
+                && (options.naanpack || options.jspack) {                   // actually building a package
+                if !pcomp.name {
+                    //
+                    // Some components cannot use a build function because they are too early in the
+                    // boot process, but we still need a component. We look for NaanBuildComponent
+                    // to define a dictionary with filename, name and manifest fields. For example,
+                    // see Util:Module.nlg
+                    //
+                    pcomp = penv.evalq(car(compress(NaanBuildComponent)))
+                    if !pcomp || !fpath.endsWith("/".concat(pcomp.filename))
+                        output.errors.push("Build cannot package without component, use NaanBuildComponent?")
+                }
+                if output.errors.length == 0 {
+                    package = util.pkgSave(compress(pcomp.name), pcomp.manifest)
+                    if string(package) {
+                        output.errors.push("Build cannot generate package: ".concat(package))
+                        package = false
+                    }
+                }
             }
+
+            annotations = output.annotations
+            if annotations.length == 0 {                                    // empty annotations list
+                if output.errors.length > 0
+                    annotations.push({                                      // first error becomes annotation
+                        row: 0
+                        column: 0
+                        text: output.errors[0]
+                        type: "error"
+                    })
+                else
+                    annotations = false }                                   // no errors or annotations
             if output.errors.length > 0 || output.text.length > 0 {
                 textline("-".repeat(79))
                 textline("While processing ", fpath)
@@ -540,22 +576,6 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
             //
             // Build the package, if not just doing syntax checking
             //
-            if options.naanpack || options.jspack {                         // actually building a package?
-                if !pcomp.name {
-                    //
-                    // Some components cannot use a build function because they are too early in the
-                    // boot process, but we still need a component. We look for NaanBuildComponent
-                    // to define a dictionary with filename, name and manifest fields. For example,
-                    // see Util:Module.nlg
-                    //
-                    pcomp = penv.evalq(car(compress(NaanBuildComponent)))
-                    if !pcomp || !fpath.endsWith("/".concat(pcomp.filename))
-                        return (list("Build cannot package without component in ".concat(fpath), false, annotations, textout))
-                }
-                package = util.pkgSave(compress(pcomp.name), pcomp.manifest)
-                if string(package)
-                    return (list("Build cannot generate package for ".concat(fpath), false, annotations, textout))
-            }
         } catch {
             if true
                 return (list("Packaging exception in ".concat(fpath, ": ", tostring(exception)), false, annotations, textout))
@@ -585,7 +605,7 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
         if !build.parallel
             build.parallel = ExecutorParallel(track, {                      // create worker pool
                 basename: "build"
-                initeval: `(false, (parseAndPack1))
+                initeval: list(quote(init1()), `(init1, parseAndPack1))
             })
         result = build.parallel.rpc(parseAndPack1, list(text, fpath, options, operation))
         if !result.0 {
@@ -1044,9 +1064,9 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
                 }
                 else if ((`(error, content) = fs.readFile(entry.readpath, readOptions)) && !error) {
                     if entry.license
-                        `(content) = applySubstitutions(content, licFileDefs)
+                        `(content) = applySubstitutions(content, licFileDefs, true)
                     if entry.version
-                        `(content) = applySubstitutions(content, verFileDefs)
+                        `(content) = applySubstitutions(content, verFileDefs, true)
                     if entry.naanpack
                         `(error, content) = parseAndPack(content, entry.readpath, { naanpack: true })
                     else if entry.jspack
@@ -1251,7 +1271,8 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
     //
     // Run the current build product by spawning a new worker.
     //
-    build.runSpawn = function runSpawn(local error, maintext, executor, vpath, site, dirpath) {
+    build.runSpawn = function runSpawn(stage,
+        local error, maintext, executor, vpath, site, dirpath) {
         `(error, maintext) = fs.readFile(JSpath.join(build.destpath, build.runway.main))
         if error
             error = Error("Builder: cannot read main file", error)
@@ -1291,13 +1312,12 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
     //
     // Run the current build product by opening a new window.
     //
-    build.runWindow = function runWindow(
+    build.runWindow = function runWindow(stage,
         local title, main, url, features, vpath, error, window, site) {
         if !js.w
             return (list(Error('Run method "window" requires browser host')))
         if !build.runway."v-site"
             return (list(Error('Run method "window" requires v-site specification')))
-        title = rules.name.concat("-", build.buildnum)
         main = build.runway.main
         if !main
             main = "index.html"
@@ -1313,6 +1333,7 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
         if error
             return (list(Error("Builder: cannot create virtual site", error)))
         sleep(1)                                                            // needed on Windows or it won't open, fiik why
+        title = rules.name.concat("-", stage, "-", operation)
         window = js.w.open(url, title, features)
         list(false, { ok: true })                                           // we don't know the executor
     }
@@ -1323,13 +1344,13 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
     // Run the current build product, which would be after the make call. Returns a standard result
     // tuple.
     //
-    build.run = function run() {
+    build.run = function run(stage) {
         if build.runway.open
             fs.shellOpen(JSpath.join(build.destpath, build.runway.open), build.runway.args)
         else if build.runway.spawn
-            build.runSpawn()
+            build.runSpawn(stage)
         else if build.runway.window
-            build.runWindow()
+            build.runWindow(stage)
         else
             list(false, { ok: true })
     }

package/frameworks/project/projects.nlg

@@ -296,7 +296,7 @@ closure projConnector(projman, projtype, local connector, watch) {
  *
  * Nide.proj/
  *      nide_cliser.cfg                 - JSON definition of the project (see below)
- *      NaanIDE_version.txt             - [default] substitution file defining 1.7.0+1 etc.
+ *      NaanIDE_version.txt             - [default] substitution file defining 1.7.2+1 etc.
  *      NaanIDE_version_builds.txt      - [default] contains current build number as decimal string
  *      build/                          - [optional] default build output location
  *      NaanIDE.lic                     - [optional] defines Zulch Laboratories, Inc. and other license info
@@ -646,7 +646,7 @@ closure projConfig(projman, where, projID, local procon, fs, configpath) {
             if builder.refresh()
                 buildonly = !buildonly                                      // reverse if refresh
             if !buildonly
-                `(error) = builder.run()
+                `(error) = builder.run(stage)
         }
         builder.destroy()
         procon.builder = false