@fnet/cli 0.3.12 → 0.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fnet/cli",
-  "version": "0.3.12",
+  "version": "0.3.15",
   "files": [
     "dist",
     "template"
@@ -36,7 +36,6 @@
     "@fnet/auto-conda-env": "^0.2.1",
     "@fnet/config": "^0.2.29",
     "@fnet/dir-zipper": "^0.1.8",
-    "@fnet/expression": "^0.1.30",
     "@fnet/files-to-gcs": "^0.3.12",
     "@fnet/key-value-transformer": "^0.1.4",
     "@fnet/npm-list-versions": "^0.1.35",
@@ -87,6 +86,7 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-terser": "^0.4.4",
+    "peggy": "^5.0.6",
     "rollup": "^4.52.5"
   }
 }

package/template/fnet/node/src/default/blocks/for.js.njk

@@ -35,31 +35,51 @@ export default function Block(context) {
         {% endif %}
       {% endif%}
 
-      for await(const {{context.transform.for.value | safe}} of {{context.transform.for.in | safe}}){
-        c.for={ {{context.transform.for.value | safe}} };
+      for await(const {{context.transform.for.as | safe}} of {{context.transform.for.in | safe}}){
+        // Create Proxy for closure-like variable resolution
+        // Local variable shadows parent, but parent scope accessible via Proxy fallback
+        const localForVar = { {{context.transform.for.as | safe}}: {{context.transform.for.as | safe}} };
+        const forProxy = new Proxy(localForVar, {
+          get(target, prop) {
+            // Check local scope first (shadowing)
+            if (prop in target) return target[prop];
+            // Fallback to parent scope
+            return c.for?.[prop];
+          }
+        });
+
+        // Create new context with updated for
+        const loopContext = { ...c, for: forProxy };
 
         {% if childs.length %}
-          let current= new {{childs[0].codeKey}}({ parent:_this, engine, flow, caller:c  });
+          let current= new {{childs[0].codeKey}}({ parent:_this, engine, flow, caller:loopContext  });
           let currentArgs=args;
 
           do {
-            
+
             {% if workflow.parent.context.atom.doc.features.print_runners %}
               console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
             {% endif %}
 
-            const nextBlock= typeof currentArgs==='undefined'? await current.run() 
-              : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
+            try {
+              const nextBlock= typeof currentArgs==='undefined'? await current.run()
+                : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
 
-            if(nextBlock?.type==='return') return resolve(nextBlock);
-            else if(nextBlock?.type!=='block') break;
+              if(nextBlock?.type==='return') return resolve(nextBlock);
+              else if(nextBlock?.type!=='block') break;
 
-            if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
-              return resolve(nextBlock);
+              if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+                return resolve(nextBlock);
+
+              current=new nextBlock.toType({ parent:_this, engine, flow, caller:loopContext, onError, error });
+              currentArgs=nextBlock.input;
+            } catch (err) {
+              if (onError) {
+                return onError(err);
+              }
+              throw err;
+            }
 
-            current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, onError, error });
-            currentArgs=nextBlock.input;
-            
           } while(true);
             
         {% endif %}

package/template/fnet/node/src/default/blocks/parallel.js.njk

@@ -55,20 +55,27 @@ export default function Block(context) {
       {% set strategy = context.transform.strategy | default('all') %}
       let results;
 
-      {% if strategy == 'race' %}
-        // Promise.race - first to complete wins
-        results = [await Promise.race(promises)];
-      {% elif strategy == 'any' %}
-        // Promise.any - first successful wins
-        results = [await Promise.any(promises)];
-      {% elif strategy == 'allsettled' %}
-        // Promise.allSettled - all complete, collect results
-        const settled = await Promise.allSettled(promises);
-        results = settled.map(r => r.status === 'fulfilled' ? r.value : null);
-      {% else %}
-        // Promise.all - all must succeed (default)
-        results = await Promise.all(promises);
-      {% endif %}
+      try {
+        {% if strategy == 'race' %}
+          // Promise.race - first to complete wins
+          results = [await Promise.race(promises)];
+        {% elif strategy == 'any' %}
+          // Promise.any - first successful wins
+          results = [await Promise.any(promises)];
+        {% elif strategy == 'allsettled' %}
+          // Promise.allSettled - all complete, collect results
+          const settled = await Promise.allSettled(promises);
+          results = settled.map(r => r.status === 'fulfilled' ? r.value : null);
+        {% else %}
+          // Promise.all - all must succeed (default)
+          results = await Promise.all(promises);
+        {% endif %}
+      } catch (err) {
+        if (onError) {
+          return onError(err);
+        }
+        throw err;
+      }
 
       // Check if any child returned or jumped
       for (const result of results) {

package/template/fnet/node/src/default/blocks/retry.js.njk

@@ -42,37 +42,44 @@ export default function Block(context){
       let lastError;
       let currentDelay = initialDelay;
 
-      for (let attempt = 1; attempt <= attempts; attempt++) {
-        try {
-          // Execute child block
-          await retryableBlock.run();
-
-          // Success! Break out of retry loop
-          break;
-        } catch (error) {
-          lastError = error;
-
-          // Last attempt failed - throw error
-          if (attempt === attempts) {
-            throw new Error(`Retry failed after ${attempts} attempts: ${error.message}`);
-          }
-
-          // Wait before retry
-          await new Promise(resolve => setTimeout(resolve, currentDelay));
-
-          // Calculate next delay based on backoff strategy
-          if (backoff === 'exponential') {
-            currentDelay = currentDelay * 2;
-          } else if (backoff === 'linear') {
-            currentDelay = currentDelay + initialDelay;
-          }
-          // 'fixed' keeps currentDelay unchanged
-
-          // Apply maxDelay cap if specified
-          if (maxDelay && currentDelay > maxDelay) {
-            currentDelay = maxDelay;
+      try {
+        for (let attempt = 1; attempt <= attempts; attempt++) {
+          try {
+            // Execute child block
+            await retryableBlock.run();
+
+            // Success! Break out of retry loop
+            break;
+          } catch (error) {
+            lastError = error;
+
+            // Last attempt failed - throw error
+            if (attempt === attempts) {
+              throw new Error(`Retry failed after ${attempts} attempts: ${error.message}`);
+            }
+
+            // Wait before retry
+            await new Promise(resolve => setTimeout(resolve, currentDelay));
+
+            // Calculate next delay based on backoff strategy
+            if (backoff === 'exponential') {
+              currentDelay = currentDelay * 2;
+            } else if (backoff === 'linear') {
+              currentDelay = currentDelay + initialDelay;
+            }
+            // 'fixed' keeps currentDelay unchanged
+
+            // Apply maxDelay cap if specified
+            if (maxDelay && currentDelay > maxDelay) {
+              currentDelay = maxDelay;
+            }
           }
         }
+      } catch (err) {
+        if (onError) {
+          return onError(err);
+        }
+        throw err;
       }
       {% endif %}
 

package/template/fnet/node/src/default/blocks/return.js.njk

@@ -15,12 +15,12 @@ export default function Block(context){
         
         const value = {{context.transform.return | safe}};
 
-        flow.result={value: value};
-
         {% include "src/default/macros/block-assign.js.njk" %}
         
         {% include "src/default/macros/block-signal.js.njk" %}
 
+        flow.result={value: value};
+
         resolve({type:'return',value: value});
 
         {% include "src/default/macros/block-run-footer.js.njk" %}

package/template/fnet/node/src/default/blocks/steps.js.njk

@@ -25,22 +25,29 @@ export default function Block(context){
         let currentArgs=args;
 
         do {
-          
+
           {% if workflow.parent.context.atom.doc.features.print_runners %}
             console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
           {% endif %}
 
-          const nextBlock= typeof currentArgs==='undefined'? await current.run() 
-            : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
+          try {
+            const nextBlock= typeof currentArgs==='undefined'? await current.run()
+              : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
 
-          if(nextBlock?.type==='return') return resolve(nextBlock);
-          else if(nextBlock?.type!=='block') break;
+            if(nextBlock?.type==='return') return resolve(nextBlock);
+            else if(nextBlock?.type!=='block') break;
 
-          if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
-            return resolve(nextBlock);
+            if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+              return resolve(nextBlock);
 
-          current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, onError, error });
-          currentArgs=nextBlock.input;
+            current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, onError, error });
+            currentArgs=nextBlock.input;
+          } catch (err) {
+            if (onError) {
+              return onError(err);
+            }
+            throw err;
+          }
 
         } while(true);
 

package/template/fnet/node/src/default/blocks/switch.js.njk

@@ -51,7 +51,14 @@ export default function Block(context) {
               console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
             {% endif %}
 
-            return resolve(Array.isArray(args)? await current.run.apply(current,args) : await current.run.call(current,args));
+            try {
+              return resolve(Array.isArray(args)? await current.run.apply(current,args) : await current.run.call(current,args));
+            } catch (err) {
+              if (onError) {
+                return onError(err);
+              }
+              throw err;
+            }
           }
       {% endfor%}
 

package/template/fnet/node/src/default/macros/block-next.js.njk

@@ -13,6 +13,7 @@ resolve ({
     fromClosure: c,
     toType:{{context.next.codeKey}},
     onError,
+    error,
     {% if context.transform.output %}
     input: {{context.transform.output | safe}},
     {% endif %}

package/template/fnet/node/src/default/macros/block-run-header.js.njk

@@ -16,7 +16,19 @@ const form=null;
 {% endif %}
 
 {# closure #}
-const c={ caller, resolve, reject, args, get form(){return form||caller?.form}, get module(){return m||caller?.module} };
+const c={
+  caller,
+  resolve,
+  reject,
+  args,
+  get form(){return form||caller?.form},
+  get module(){return m||caller?.module},
+  get for(){
+    // Proxy pattern for nested loop variable resolution with closure semantics
+    // Inner loops shadow outer loops, but parent scope is accessible via fallback
+    return caller?.for || {};
+  }
+};
 
 {% if workflow.parent.context.atom.doc.features.print_steps %}
 console.log(new Date().toLocaleString(),'{{indexKey}}');

package/template/fnet/node/src/default/workflow.js.njk

@@ -96,10 +96,10 @@ export default class Workflow extends Object {
         if(nextBlock?.type==='return') return nextBlock;
         else if(nextBlock?.type!=='block') break;
 
-        if(nextBlock.toType.ParentTypeId!==this.constructor.TypeId) 
+        if(nextBlock.toType.ParentTypeId!==this.constructor.TypeId)
           throw new Error('Unknown situation');
-        
-        current=new nextBlock.toType({ parent:this, engine:this.engine, flow:this, caller:c });
+
+        current=new nextBlock.toType({ parent:this, engine:this.engine, flow:this, caller:c, onError:nextBlock.onError, error:nextBlock.error });
         currentArgs=nextBlock.input;
 
       } while(true);