@naanlang/naan 1.4.0 → 1.4.2

package/frameworks/running/debugnub.nlg

@@ -33,6 +33,9 @@ closure DebugNub(local nub, debug, paused) {
     nub.codemgr = CodeManager()
     nub.exenable = true
     nub.watches = []
+    nub.contIDs = new(weakmap)
+    nub.stacks = { }
+    nub.usage = { }
 
     // debugDepth
     // Return the recursive debugging depth as an integer.
@@ -80,7 +83,7 @@ closure DebugNub(local nub, debug, paused) {
             for frame in nub.frames
                 if procedure(frame)
                     break
-            `(procdef, task) = nub.procTask(frame)
+            `(procdef, task) = debug.frameProcTask(frame)
         }
         if !procdef
             return (false)
@@ -396,14 +399,75 @@ closure DebugNub(local nub, debug, paused) {
             output.push(breakInfo(bpid))
         output
     }
+    
+    // procLoc
+    //
+    // Get the location of a procdef.
+    
+    nub.procLoc = function procLoc(procdef, task, local comp, position) {
+        if !task
+            task = rrrest(procdef)
+        comp = nub.codemgr.procComponent(procdef)
+        position = comp.textpos(procdef, task)
+        {
+            modname:    comp.modname
+            compname:   comp.compname
+            first:      position.first
+            last:       position.last
+            line:       position.line
+        }
+    }
+
+    // getContID
+    //
+    // Get the contID for a continuation.
+    
+    nub.getContID = function getContID(cont, local contID, frames) {
+        contID = nub.contIDs[cont]
+        if !contID
+            nub.contIDs[cont] = contID = UUID()
+        frames = cont.stacktrace().toarray
+        if frames.slice(-1).0 == `interrupt
+            frames.pop()
+        nub.stacks[contID] = frames
+        contID
+    }
+
+    // contGC
+    //
+    // Remove any continuations that are not in the specified array.
+    
+    nub.contGC = function contGC(contIDs, local contID) {
+        contIDs = contIDs.concat(nub.usage.*.toarray)                       // keep preserved ids
+        for contID in nub.stacks
+            if contIDs.indexOf(contID) < 0
+                nub.stacks[contID] = undefined
+    }
+    
+    // usingContID
+    //
+    // Mark that the contID is being used.
+    //
+    nub.usingContID = function usingContID(contID, usage) {
+        if nub.usage[contID]
+            nub.usage[contID] += usage
+        else if usage > 0
+            nub.usage[contID] = usage
+        if nub.usage[contID] == 0
+            nub.usage[contID] = undefined
+    }
 
     // callStack
     //
-    // List our callers as of the last entry.
+    // List our callers as of the last entry in the optional frames or current debugger stack.
     
-    nub.callStack = function callStack(local output, frame, type, record) {
+    nub.callStack = function callStack(contID, local frames, output, frame, type, record) {
         output = []
-        for frame in nub.frames {
+        if contID
+            frames = nub.stacks[contID]
+        else
+            frames = nub.frames
+        for frame in frames {
             record = {
                 type:       frame.0.tostring                                // e.g. "function"
             }
@@ -425,8 +489,12 @@ closure DebugNub(local nub, debug, paused) {
     //
     // Return the nth stack frame in the list returned by callStack above.
     
-    nub.nthFrame = function nthFrame(nth, local frame) {
-        for frame in nub.frames
+    nub.nthFrame = function nthFrame(nth, contID, local frames, frame) {
+        if contID
+            frames = nub.stacks[contID]
+        else
+            frames = nub.frames
+        for frame in frames
             if procedure(frame) || frame.0.tostring == "interrupt" {
                 if nth-- == 0
                     return (frame)
@@ -469,14 +537,15 @@ closure DebugNub(local nub, debug, paused) {
 
     // evalWatchesInFrame
     //
-    //     Parse and evaluate our watchpoints, optionally in the context of the nth frame. Each entry
-    // in the returned array is for a watchpoint, comprising a tuple: `(error, expression, evaluated)
+    //     Parse and evaluate our watchpoints, optionally in the context of the nth frame of the
+    // specified continuation or the current debugger stack. Each entry in the returned array is for
+    // a watchpoint, comprising a tuple: `(error, expression, evaluated).
     
-    nub.evalWatchesInFrame = function evalWatchesInFrame(nth,
+    nub.evalWatchesInFrame = function evalWatchesInFrame(nth, contID,
         local frame, locals, ns, mod, gohome, texts, watch, exprs, error, expr)
     {
         if integer(nth) {
-            frame = nthFrame(nth)
+            frame = nthFrame(nth, contID)
             locals = localist(frame)
             ns = frame.3.1.namespace
             if ns !== nsactive().0 {
@@ -506,8 +575,29 @@ closure DebugNub(local nub, debug, paused) {
     //
     // Return procedure and task from a frame, as a `(procdef, task) tuple.
     
-    nub.procTask = function procTask(frame) {
-        debug.frameProcTask(frame)
+    nub.procTask = function procTask(frame, contID, local frames, ftrav, procdef, bodydef) {
+        if contID
+            frames = new(nub.stacks[contID])
+        else
+            frames = new(debug.frames)
+        loop {
+            if frames.length == 0
+                break
+            ftrav = frames.shift()
+            if ftrav eq frame
+                frame = false                                               // can now stop on our desired procedure
+            if procedure(ftrav) {
+                if !frame {
+                    procdef = ftrav.3                                       // first procedure definition starting with desired frame
+                    if !bodydef
+                        bodydef = procdef                                   // use procdef as body if no body frame found
+                    break }
+                bodydef = false }                                           // any previously-found body applies to wrong procedure
+            else if ftrav.0 == `body || ftrav.0 == `loop {
+                if !bodydef
+                    bodydef = ftrav.2 } }                                   // use first body found before desired procedure
+        if procdef
+            list(procdef, bodydef)                                          // found valid location
     }
     
     // lastStepValue

package/frameworks/running/debugutil.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2021 by Richard C. Zulch
+ * Copyright (c) 2021-2024 by Richard C. Zulch
  *
  */
 
@@ -260,24 +260,33 @@ closure DebugRemote(commander, local remoter, here, there, library) {
     here.breakInfo = function breakInfo(bpid) {
         libBreakInfo(bpid)
     }
+    
+    // usingContID
+    //
+    // Mark that the contID is being used.
+    //
+    here.usingContID = function usingContID(contID, usage) {
+        debugNub = car(compress("debugNub"))
+        debugNub.usingContID(contID, usage)
+    }
 
     // callstack
     //
-    // Report current callstack.
+    // Report the specified fiber callstack or current debugger stack.
     //
-    here.callStack = function callStack(local debugNub) {
+    here.callStack = function callStack(contID, local debugNub) {
         debugNub = car(compress("debugNub"))
-        debugNub.callStack()
+        debugNub.callStack(contID)
     }
     
     // frameinfo
     //
-    // Report information about the nth frame in the callStack.
+    // Report information about the nth frame in a fiber callstack or the current debugger stack.
     //
-    here.frameinfo = function frameinfo(nth, local debugNub, frame, proctask, comp, position) {
+    here.frameinfo = function frameinfo(nth, contID, local debugNub, frame, proctask, comp, position) {
         debugNub = car(compress("debugNub"))
-        frame = debugNub.nthFrame(nth)
-        proctask = debugNub.procTask(frame)
+        frame = debugNub.nthFrame(nth, contID)
+        proctask = debugNub.procTask(frame, contID)
         comp = debugNub.codemgr.procComponent(proctask.0)
         position = comp.textpos(proctask.0, proctask.1)
         {
@@ -302,11 +311,11 @@ closure DebugRemote(commander, local remoter, here, there, library) {
     //     The optional visible array is a preceding result of this function, where "visible=true"
     // can be applied to nested values to add recursive depth.
     //
-    here.scopeinfo = function scopeinfo(nth, visible,
+    here.scopeinfo = function scopeinfo(nth, visible, contID
         local debugNub, frame, procsym, parent, proc, lex1, ex1, params, content, scope, level, level1)
     {
         debugNub = car(compress("debugNub"))
-        frame = debugNub.nthFrame(nth)
+        frame = debugNub.nthFrame(nth, contID)
         procsym = frame.3.1
         parent = procsym@\.parent
         while parent {
@@ -370,11 +379,11 @@ closure DebugRemote(commander, local remoter, here, there, library) {
     // can be applied to nested values to add recursive depth. A stack frame index can be specified
     // to evaluate an expression in that context.
 
-    here.watchInfo = function watchInfo(visible, nth,
+    here.watchInfo = function watchInfo(visible, nth, contID,
         local debugNub, values, content, watch, child1, error, value, level, expr)
     {
         debugNub = car(compress("debugNub"))
-        values = debugNub.evalWatchesInFrame(nth)
+        values = debugNub.evalWatchesInFrame(nth, contID)
         visible = new(visible)                                              // don't modify original
         content = []
         for watch in debugNub.watches {
@@ -417,8 +426,9 @@ closure DebugRemote(commander, local remoter, here, there, library) {
     //
     // List the current futures.
     
-    here.futureslist = function futureslist(local debugNub, output, future, record, procsym) {
+    here.futureslist = closure futureslist(local debugNub, contIDs, output, future, record, procsym) {
         debugNub = car(compress("debugNub"))
+        contIDs = []
         output = []
         for future in futures() {
             if member(debugNub.pauser, future.waiting)
@@ -431,6 +441,7 @@ closure DebugRemote(commander, local remoter, here, there, library) {
             if procedure(future.execute) {
                 procsym = future.execute.1
                 record.execute = strcat(future.execute.0, space, procsym.namespace.tostring, "::", debugNub.procname(procsym))
+                record.execloc = debugNub.procLoc(future.execute)
             }
             else if future.execute
                 record.execute = tostring(future.execute)
@@ -439,9 +450,15 @@ closure DebugRemote(commander, local remoter, here, there, library) {
                     procsym = item.1
                     strcat(item.0, space, procsym.namespace.tostring, "::", debugNub.procname(procsym))
                 })
+                record.continuations = future.continuations.toarray.map(function(cont, local contID) {
+                    contID = debugNub.getContID(cont)
+                    contIDs.push(contID)
+                    contID
+                })
             }
             output.push(record)
         }
+        debugNub.contGC(contIDs)
         output
     }
 

package/frameworks/running/executors.nlg

@@ -71,10 +71,14 @@ closure ExecutorBase(track, type, name, local exec) {
     
     // execSetStatus
     //
-    // Received a status update from the instance.
+    // Received a status update from the instance. This makes a copy of the specified dictionary for
+    // garbage collection, because if we store the status from a separate vsite window then it can
+    // cause the main window to retain a vsite window after it's closed. The last status update sets
+    // an object in the context of the detached window, and then it never gets updated until the
+    // executor goes away. That doesn't always happen as soon as you think.
     //
     exec.execSetStatus = function execSetStatus(status) {
-        exec.xstatus = status
+        exec.xstatus = new(status)                                          // for GC (!)
     }
     
     // execFailed
@@ -218,7 +222,7 @@ closure ExecutorContext(exec, state, local context, coder, util) {
         else if result.1.result
             list(false, caar(util.pkgLoad(result.1.result, {
                 localroots: false
-                intern: false
+                intern: "symbols"
                 execute: false
                 objectDecoder: coder.decodeObject
             })))

package/frameworks/running/running.nlg

@@ -207,12 +207,26 @@ closure packageCoder(evalf, local coder) {
                     quote(x@\.tostring = function() { "{proxy ${nn}}" }),
                     quote(x@\.undefined = closure undef args {
                         let (result) {
-                            result = evalf(list(`\.execute\-method, objectID, args))
+                            result = evalf(list(`\.invoke\-method, objectID, args))
                             if result.0
                                 throw("remoting failure: ${ErrorString(result.0)}")
                             else
                                 result.1
                         } ()
+                    }),
+                    quote(x@\.\.undefined = function (key, local result) {
+                        result = evalf(list(`\.invoke\-method, objectID, list(`\.\.undefined, key)))
+                        if result.0
+                            throw("remoting failure: ${ErrorString(result.0)}")
+                        else
+                            result.1
+                    }),
+                    quote(x@\.\=undefined = function (key, value, local result) {
+                        result = evalf(list(`\.invoke\-method, objectID, list(`\.\=undefined, key, value)))
+                        if result.0
+                            throw("remoting failure: ${ErrorString(result.0)}")
+                        else
+                            result.1
                     }), `x)))
             } (ident.name, ident.objectID)
             coder.wmapEncoding[obj] = ident
@@ -225,12 +239,18 @@ closure packageCoder(evalf, local coder) {
     //
     // Invoke a local object method from the remote proxy, returning a result tuple.
     //
-    coder.invokeMethod = closure invokeMethod(objectID, args, local obj) {
+    coder.invokeMethod = closure invokeMethod(objectID, args, local obj, method) {
         obj = coder.mapDecoding[objectID]
-        if obj
-            list(false, eval(list(deref, obj, pop(args), args)))
-        else
-            list(Error("object ${objectID} not found"))
+        method = pop(args)
+        if obj {
+            if method == `\.\.undefined
+                obj[args.0]
+            else if method == `\.\=undefined
+                obj[args.0] = args.1
+            else
+                eval(list(deref, obj, method, args))
+        } else
+            throw("remoting error: object ${objectID} not found")
     }
 
     // finis

package/frameworks/running/sourcecode.nlg

@@ -87,12 +87,14 @@ closure CodeManager(options,  local coman, cache)
                 output.push(false)
                 continue
             }
+            if text.startsWith("!")
+                text = "(${text})"                                          // no shell escapes here
             try {
                 source = new(textstream, text.concat(" ;"))                 // avoid EOF
                 if locals
                     source.setsymbols(locals)
                 registry = modlist().Lib.exports.Registry                   // dialect registry
-                dialect = registry.findName(registry.dialects().0)          // ### default dialecct
+                dialect = registry.findName(registry.dialects().0)          // ### default dialect
                 output.push(dialect.parse(source))
             } catch {
                 if true {

package/frameworks/running/taskexec.nlg

@@ -88,7 +88,7 @@ closure TaskDispatcher(replier, local contexts, gohome, coder, util) {
                         objectDecoder: coder.decodeObject
                     })
                     expr = caar(expr)
-                    if expr.0 == `\.execute\-method
+                    if expr.0 == `\.invoke\-method
                         expr = coder.invokeMethod(expr.1, expr.2)           // object method, args
                     else
                         expr = evalactive(expr)                             // evaluate expression

package/frameworks/storage/dbt_pouch.nlg

@@ -34,13 +34,17 @@
  *
  */
 
-closure dapoTable(database, path, local table, prefix) {
+closure dapoTable(database, rootpath, local table, prefix) {
     global()
+    if !database || !string(rootpath)
+        return (list(Error("invalid arguments")))
     table = new(object, this)
     table.type = database.type
     table.db = database
-    table.path = path
-    table.prefix = makePrefix(path)
+    if rootpath != "" && rootpath.slice(-1) != "/"
+        rootpath = rootpath.concat("/")                                     // "" or "<path>/"
+    table.rootpath = rootpath
+    table.prefix = makePrefix(rootpath)
         
     // makePrefix
     //
@@ -80,7 +84,7 @@ closure dapoTable(database, path, local table, prefix) {
             return (syncAdapter(add, key, content, metadata))
         id = makeID(key)
         if !string(id)
-            return (asyncResult(callback, id))                                 // error from makeID
+            return (asyncResult(callback, id))                              // error from makeID
         if metadata && !dictionary(metadata)
             return (asyncResult(callback, Error("invalid arguments")))
         if !database.pouch
@@ -291,7 +295,7 @@ closure dapoTable(database, path, local table, prefix) {
     // only immediate children are listed, with directories at the end--and no metadata for them.
     //
 
-    table.records = closure records(options, callback, local prefix, pouchOpts, output) {
+    table.records = closure records(options, callback, local prefix, prelen, pouchOpts, output) {
         if !callback
             return (syncAdapter(records, options))
         output = {
@@ -300,9 +304,11 @@ closure dapoTable(database, path, local table, prefix) {
             if !string(options.prefix)
                 return (asyncResult(callback, Error("prefix option must be string")))
             output.prefix = options.prefix
-            prefix = table.prefix.concat(makePrefix(options.prefix)) }
-        else
+            prefix = table.prefix.concat(makePrefix(options.prefix))
+            prelen = options.prefix.length }
+        else {
             prefix = table.prefix
+            prelen = 0 }
         if !database.pouch
             return (asyncResult(callback, Error("database closed")))
         pouchOpts = {
@@ -321,19 +327,24 @@ closure dapoTable(database, path, local table, prefix) {
                         key = obj.id.substring(table.prefix.length)
                     else
                         key = "*key error*"                                 // should not happen
-                    if !options.deep {
-                        offset = key.indexOf("/", prefix.length)
-                        if offset >= 0 {
-                                key = key.substring(0, offset+1)            // child directory name
-                                if !firstkids[key]
-                                    firstkids[key] = key                    // first time we've seen this child directory
-                                else
-                                    continue } }                            // ignore deeper child
                     item = {
                         key:        key
                         _id:        obj.id
                         _rev:       obj.value.rev
                     }
+                    if !options.deep {
+                        offset = key.indexOf("/", prelen)                   // start looking past options.prefix
+                        if offset >= 0 {                                    // directory child
+                            if length(key) > offset+1 {                     // transitive child (not directory itself)
+                                obj.doc = undefined                         // just record directory name
+                                item._id = undefined
+                                item._rev = undefined }
+                            key = key.substring(0, offset+1)                // child directory name
+                            if !firstkids[key]
+                                firstkids[key] = key                        // first time we've seen this child directory
+                            else
+                                continue                                    // ignore deeper child
+                            item.key = key } }
                     if obj.doc {                                            // docs were requested
                         if obj.doc.content {
                             item._md5 = HashMD5(obj.doc.content)
@@ -518,7 +529,7 @@ closure DbConnector(psm, local connClassID, connector, watch) {
     
     // localDBcred
     //
-    // True iff the specified credential dictionary is for a local browser DB.
+    // True iff the specified credential dictionary is for a local DB.
     function localDBcred(creds) {
         !creds.authName && creds.urlName.indexOf("://") < 0
     }
@@ -711,8 +722,13 @@ closure DbConnector(psm, local connClassID, connector, watch) {
         if creds {
             if creds.label
                 info.name = creds.label
-            if localDBcred(creds)
-                info.type = "browser storage"
+            if localDBcred(creds) {
+                if js.w
+                    info.type = "PouchDB-browser"
+                else
+                    info.type = "PouchDB-filesystem"
+            } else
+                info.type = "PouchDB-network"
             if creds.locked
                 info.locked = true
             if creds.hidden
@@ -741,6 +757,8 @@ closure DbConnector(psm, local connClassID, connector, watch) {
     //
     // Connect to a database, returning a PSM view.
     connector.connect = function connect(resID, service, args, local error, creds, db, rootpath, table) {
+        if !resID || args && !tuple(args)
+            return (list(Error("invalid arguments")))
         `(error, creds) = connector.access(resID)
         if !error
             `(error, db) = PouchDB(creds)
@@ -751,7 +769,7 @@ closure DbConnector(psm, local connClassID, connector, watch) {
         else if service == "NideFS" {
             rootpath = args.0                                               // connect to a NideFS filesystem
             if !rootpath
-                return (Error("mandatory rootpath missing"))
+                return (list(Error("mandatory rootpath missing")))
             `(error, table) = db.table(rootpath)
             if error
                 list(error)

package/frameworks/storage/file_manager.nlg

@@ -766,7 +766,7 @@ function fimaInit(local manifest) {
 
     manifest = `(FileManager, fimaStore, fimaInit)
 
-    Naan.module.build(module.id, "fileManager", function(modobj, compobj) {
+    Naan.module.build(module.id, "file_manager", function(modobj, compobj) {
         require("./storage.nlg")
         commonWatching = require("../common/watching.nlg")
         compobj.manifest = manifest

package/frameworks/storage/psm_dbtables.nlg

@@ -38,10 +38,12 @@
 
 closure FSview(table, rootpath, local view) {
     global(JSpath)
-    if !table
+    if !table || !string(rootpath)
         return (list(Error("invalid arguments")))
     view = new(object, this)
     view.table = table
+    if rootpath != "" && rootpath.slice(-1) != "/"
+        rootpath = rootpath.concat("/")                                     // "" or "<path>/"
     view.rootpath = rootpath
     view.path = JSpath.posix                                                // for view.path.join(), etc.
 
@@ -118,23 +120,21 @@ closure FSview(table, rootpath, local view) {
     // checkPathName
     //
     // Return a `(path, name) tuple for a directory, or false if callback executed due to error. The
-    // name is the empty string if the path is empty. Path "/" has name "/". Otherwise the name is
-    // the last segment of the path, omitting the trailing slash.
+    // name is the empty string if the path is empty. Path "/" has name "". Otherwise the name is the
+    // last segment of the path, omitting any trailing slash. A key invariant is that the information
+    // should be the same whether the pathname was part of the rootpath or specified in the source
+    // path to an operation. That is why this "steals" the rootpath name if needed.
     //
-    function checkPathName(path, callback, local name, slashdex) {
-        if path == ""
-            name = ""
-        else {
-            if checkPath(path, callback)
-                return (false)                                              // non-string
-            if path.slice(-1) != "/"
-                path = path.concat("/")                                     // force to be directory
-            slashdex = path.lastIndexOf("/", path.length-2)
-            if path == "/" || slashdex < 0
-                name = path
-            else
-                name = path.slice(slashdex+1, -1)                           // omit trailing "/"
-        }
+    function checkPathName(path, callback, local name) {
+        if checkPath(path, callback)
+            return (false)                                                  // non-string
+        if path != "" && path.slice(-1) != "/"
+            path = path.concat("/")                                         // force to be directory
+        if path == "/" && rootpath != ""
+            name = rootpath                                                 // avoid making "//"
+        else
+            name = rootpath.concat(path)
+        name = name.split("/").slice(0,-1).pop() || ""                      // <|| ""> not needed
         list(path, name)
     }
 
@@ -683,7 +683,7 @@ closure FSview(table, rootpath, local view) {
             return                                                          // already executed callback with error
         dirdict = {
             name: name
-            path: path
+            path: rootpath.concat(path)
             data: {
                 platform: table.type
                 semantics: "dbfs"
@@ -715,8 +715,8 @@ closure FSview(table, rootpath, local view) {
                             finfo.type = "directory"
                     } else if !finfo.type
                         finfo.type = "file"                                 // everything is a file in UNIX
-                    finfo.md5 = item.doc._md5 || undefined
-                    finfo.length = item.doc._length || item.doc.length || undefined
+                    finfo.md5 = item._md5 || item.doc._md5 || undefined
+                    finfo.length = item._length || item.doc._length || item.doc.length || undefined
                     if item.key.length > offset                             // not the directory itself
                         dirdict.children.push({
                             name: name
@@ -743,14 +743,13 @@ closure FSview(table, rootpath, local view) {
         `(path, name) = checkPathName(path, callback)
         if !path
             return                                                          // already executed callback with error
-        options = {                                                         // ### might want to allow some options
+        options = merge({
             prefix: path
             deep: true
-        }
-        if name == "" && rootpath != ""
-            name = rootpath.split("/").slice(0,-1).pop() || ""
+        }, options)
         treedict = {
             name: name
+            path: rootpath.concat(path)
             data: {
                 platform: table.type
                 semantics: "dbfs"

package/frameworks/storage/resources.nlg

@@ -142,9 +142,14 @@ closure ResourceManager(dbname, prefix, local reman, watch, result) {
     reman.unWatch = watch.unWatch
     reman.dbname = dbname
     reman.conns = {}
-    result =  PouchDB(dbname)
+    try {
+        require("./dbt_pouch.nlg")
+        result = PouchDB(dbname)
+    } catch {
+        result = list(Error("PouchDB not available", exception))
+    }
     if result.0
-        return (result)                                                     // can't access our vault database
+        return (list(result))                                               // can't access our vault database
     reman.db = result.1
     
     // vault
@@ -423,19 +428,22 @@ closure ResourceTracker(reman, local retor, watch) {
     // Start tracking resources.
     retor.open = function open() {
         if retor.classIdList
-            return                                                          // already open
+            return (list(false, { open: true }))                            // already open
         watch.reset()
         retor.resids = { }                                                  // start empty
         retor.classIdList = []
         for classID in reman.connectors()
             addConnResources(classID)
         reman.watch(remanUpdateOnChange)
+        list(false, { ok: true })
     }
     
     // close
     //
     // stop tracking resources.
     retor.close = function close(local classID, connector) {
+        if !retor.classIdList
+            return (list(false, { open: false }))
         watch.reset()
         if retor.classIdList {
             for classID in retor.classIdList {
@@ -446,6 +454,7 @@ closure ResourceTracker(reman, local retor, watch) {
         }
         reman.unWatch(remanUpdateOnChange)
         retor.resids = false
+        list(false, { ok: true })
     }
 
     // finis
@@ -466,7 +475,6 @@ function rsrcInit(local manifest) {
 
     Naan.module.build(module.id, "resources", function(modobj, compobj) {
         require("./storage.nlg")
-        require("./dbt_pouch.nlg")
         commonWatching = require("../common/watching.nlg")
         compobj.manifest = manifest
         module.exports.ResourceManager = ResourceManager