@weborigami/language 0.6.11 → 0.6.12

package/main.js

@@ -13,11 +13,9 @@ export { default as projectRoot } from "./src/project/projectRoot.js";
 export { default as projectRootFromPath } from "./src/project/projectRootFromPath.js";
 export * as Protocols from "./src/protocols/protocols.js";
 export { formatError, highlightError, lineInfo } from "./src/runtime/errors.js";
+export { default as evaluate } from "./src/runtime/evaluate.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
-export {
-  default as evaluate,
-  default as execute,
-} from "./src/runtime/execute.js";
+export { default as execute } from "./src/runtime/execute.js";
 export * as expressionFunction from "./src/runtime/expressionFunction.js";
 export { default as expressionObject } from "./src/runtime/expressionObject.js";
 export * from "./src/runtime/handleExtension.js";

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.11",
+  "version": "0.6.12",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "24.10.1",
+    "@types/node": "25.3.2",
     "peggy": "5.0.6",
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.11",
+    "@weborigami/async-tree": "0.6.12",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
-    "yaml": "2.8.1"
+    "yaml": "2.8.2"
   },
   "scripts": {
     "build": "peggy --allowed-start-rules=\"*\" --format es src/compiler/origami.pegjs --output src/compiler/parse.js",

package/src/compiler/origami.pegjs

@@ -845,8 +845,10 @@ relationalExpression
   // We disallow a newline before the relational operator to support a newline
   // as a separator in an object literal that has an object shorthand property
   // with an angle bracket path. Otherwise the opening angle bracket would be
-  // interpreted as a relational operator.
-  = head:shiftExpression tail:(inlineSpace @relationalOperator __ @shiftExpression)* {
+  // interpreted as a relational operator. In shell mode we require a space to
+  // avoid ambiguity with an angle bracket literal as an argument in an implicit
+  // parentheses call.
+  = head:shiftExpression tail:(inlineSpace @relationalOperator whitespaceRequiredForShell @shiftExpression)* {
       return tail.reduce(makeBinaryOperation, head);
     }
 
@@ -1039,9 +1041,9 @@ uriKey
 
 // A single character in a URI key
 uriKeyChar
-  // Accept anything that doesn't end the URI key or path
-  // Reject whitespace; see notes for `whitespace` term
-  = char:[^/,\)\]\}] !&{ return /\s/.test(char); } { return char; }
+  // Accept anything except whitespace (see notes for `whitespace` term),
+  // brackets, comma, or slash
+  = char:[^/,\(\[\{\)\]\}] !&{ return /\s/.test(char); } { return char; }
   / escapedChar
 
 // A slash-separated path of keys: `a/b/c`
@@ -1071,6 +1073,10 @@ whitespaceOptionalForProgram
   = programMode __
   / shellMode
 
+whitespaceRequiredForShell
+  = shellMode whitespace
+  / programMode __
+
 whitespaceOrParenthesis
   = whitespace
   / "("

package/src/compiler/parse.js

@@ -357,6 +357,7 @@ function peg$parse(input, options) {
     whitespace: peg$parsewhitespace,
     whitespaceChar: peg$parsewhitespaceChar,
     whitespaceOptionalForProgram: peg$parsewhitespaceOptionalForProgram,
+    whitespaceRequiredForShell: peg$parsewhitespaceRequiredForShell,
     whitespaceOrParenthesis: peg$parsewhitespaceOrParenthesis,
     whitespaceWithNewLine: peg$parsewhitespaceWithNewLine,
   };
@@ -459,7 +460,7 @@ function peg$parse(input, options) {
   const peg$r19 = /^[^\n\r]/;
   const peg$r20 = /^[!+]/;
   const peg$r21 = /^[\/)\]}]/;
-  const peg$r22 = /^[^\/,)\]}]/;
+  const peg$r22 = /^[^\/,([{)\]}]/;
   const peg$r23 = /^[a-z]/;
   const peg$r24 = /^[a-z0-9+-.]/;
   const peg$r25 = /^[:]/;
@@ -589,7 +590,7 @@ function peg$parse(input, options) {
   const peg$e122 = peg$literalExpectation("await", false);
   const peg$e123 = peg$literalExpectation("typeof", false);
   const peg$e124 = peg$literalExpectation("void", false);
-  const peg$e125 = peg$classExpectation(["/", ",", ")", "]", "}"], true, false, false);
+  const peg$e125 = peg$classExpectation(["/", ",", "(", "[", "{", ")", "]", "}"], true, false, false);
   const peg$e126 = peg$otherExpectation("slash-separated path");
   const peg$e127 = peg$classExpectation([["a", "z"]], false, false, false);
   const peg$e128 = peg$classExpectation([["a", "z"], ["0", "9"], ["+", "."]], false, false, false);
@@ -6313,10 +6314,15 @@ function peg$parse(input, options) {
       if (s4 !== peg$FAILED) {
         s5 = peg$parserelationalOperator();
         if (s5 !== peg$FAILED) {
-          s6 = peg$parse__();
-          s7 = peg$parseshiftExpression();
-          if (s7 !== peg$FAILED) {
-            s3 = [ s5, s7 ];
+          s6 = peg$parsewhitespaceRequiredForShell();
+          if (s6 !== peg$FAILED) {
+            s7 = peg$parseshiftExpression();
+            if (s7 !== peg$FAILED) {
+              s3 = [ s5, s7 ];
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
           } else {
             peg$currPos = s3;
             s3 = peg$FAILED;
@@ -6336,10 +6342,15 @@ function peg$parse(input, options) {
         if (s4 !== peg$FAILED) {
           s5 = peg$parserelationalOperator();
           if (s5 !== peg$FAILED) {
-            s6 = peg$parse__();
-            s7 = peg$parseshiftExpression();
-            if (s7 !== peg$FAILED) {
-              s3 = [ s5, s7 ];
+            s6 = peg$parsewhitespaceRequiredForShell();
+            if (s6 !== peg$FAILED) {
+              s7 = peg$parseshiftExpression();
+              if (s7 !== peg$FAILED) {
+                s3 = [ s5, s7 ];
+              } else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+              }
             } else {
               peg$currPos = s3;
               s3 = peg$FAILED;
@@ -7834,6 +7845,40 @@ function peg$parse(input, options) {
     return s0;
   }
 
+  function peg$parsewhitespaceRequiredForShell() {
+    let s0, s1, s2;
+
+    s0 = peg$currPos;
+    s1 = peg$parseshellMode();
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parsewhitespace();
+      if (s2 !== peg$FAILED) {
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseprogramMode();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parse__();
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+
+    return s0;
+  }
+
   function peg$parsewhitespaceOrParenthesis() {
     let s0;
 
@@ -8075,6 +8120,7 @@ const peg$allowedStartRules = [
   "whitespace",
   "whitespaceChar",
   "whitespaceOptionalForProgram",
+  "whitespaceRequiredForShell",
   "whitespaceOrParenthesis",
   "whitespaceWithNewLine"
 ];

package/src/handlers/sh_handler.js

@@ -26,10 +26,15 @@ export default {
  * Supports multiple commands, pipelines, redirects, etc.
  *
  * @param {string} scriptText - Shell code (may contain newlines/side effects)
- * @param {string} inputText  - Text to pipe to the script's stdin
+ * @param {import("@weborigami/async-tree").Stringlike} inputText  - Text to pipe to the script's stdin
  * @returns {Promise<string>}
  */
 function runShellScript(scriptText, inputText) {
+  if (inputText instanceof Function) {
+    throw new Error(
+      "A .sh file expects text input but got a function instead. Did you mean to invoke the function?",
+    );
+  }
   return new Promise((resolve, reject) => {
     // Use sh -c "<scriptText>" so stdin is free for inputText
     const child = spawn("sh", ["-c", scriptText], {
@@ -49,7 +54,7 @@ function runShellScript(scriptText, inputText) {
       if (code !== 0) {
         /** @type {any} */
         const err = new Error(
-          `Shell exited with code ${code}${stderr ? `: ${stderr}` : ""}`
+          `Shell exited with code ${code}${stderr ? `: ${stderr}` : ""}`,
         );
         err.code = code;
         err.stdout = stdout;

package/src/runtime/WatchFilesMixin.d.ts

@@ -1,5 +1,7 @@
 import { Mixin } from "../../index.ts";
 
-declare const WatchFilesMixin: Mixin<{}>;
+declare const WatchFilesMixin: Mixin<{
+  watch(): Promise<void>;
+}>;
 
 export default WatchFilesMixin;

package/src/runtime/WatchFilesMixin.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import path from "node:path";
 import Watcher from "watcher";
 import TreeEvent from "./TreeEvent.js";
 
@@ -17,6 +18,12 @@ export default function WatchFilesMixin(Base) {
     onChange(filePath) {
       // Reset cached values.
       this.subfoldersMap = new Map();
+
+      // Special case: ignore events in .git folder
+      if (filePath.includes(`${path.sep}.git${path.sep}`)) {
+        return;
+      }
+
       this.dispatchEvent(new TreeEvent("change", { filePath }));
     }
 

package/src/runtime/execute.js

@@ -19,23 +19,13 @@ export default async function execute(code, state = {}) {
     return code;
   }
 
-  let evaluated;
-  if (code[0]?.unevaluatedArgs) {
-    // Don't evaluate instructions, use as is.
-    evaluated = code;
-  } else {
-    // Evaluate each instruction in the code.
-    evaluated = await Promise.all(
-      code.map((instruction) => execute(instruction, state)),
-    );
-  }
-
   // Add the code to the runtime state
   /** @type {import("../../index.ts").CodeContext} */
   const context = { state, code };
 
-  // The head of the array is a function or a map; the rest are args or keys.
-  let [fn, ...args] = evaluated;
+  // Start by evaluating the head of the instruction
+  const [head, ...tail] = code;
+  let fn = await execute(head, state);
 
   if (!fn) {
     // The code wants to invoke something that's couldn't be found in scope.
@@ -53,6 +43,17 @@ export default async function execute(code, state = {}) {
     fn = await fn.unpack();
   }
 
+  let args;
+  if (fn?.unevaluatedArgs) {
+    // Don't evaluate instructions, use as is.
+    args = tail;
+  } else {
+    // Evaluate each instruction in the code.
+    args = await Promise.all(
+      tail.map((instruction) => execute(instruction, state)),
+    );
+  }
+
   if (fn.needsState) {
     // The function is an op that wants the runtime state
     args.push(state);