@weborigami/language 0.6.6 → 0.6.8

package/index.ts

@@ -1,5 +1,11 @@
+/**
+ * Origami is a JavaScript project, but we use TypeScript as an internal tool to
+ * confirm our code is type safe.
+ */
+
 import { SyncOrAsyncMap, UnpackFunction } from "@weborigami/async-tree";
 
+// Re-export all exports from main.js
 export * from "./main.js";
 
 /**
@@ -57,8 +63,8 @@ export type Position = {
 }
 
 export type RuntimeState = {
-  /** The container (e.g., file system) that holds the code */
-  container?: SyncOrAsyncMap | null;
+  /** The container (e.g., file system folder) that holds the code */
+  parent?: SyncOrAsyncMap | null;
   /** The object to which this code is attached */
   object?: SyncOrAsyncMap | null;
   /** The current stack of function parameter assignments */

package/main.js

@@ -2,8 +2,9 @@ export * from "./src/runtime/internal.js";
 
 export * as compile from "./src/compiler/compile.js";
 export { default as isOrigamiFrontMatter } from "./src/compiler/isOrigamiFrontMatter.js";
+export { parse } from "./src/compiler/parse.js";
+export * from "./src/compiler/parserHelpers.js";
 export * as Handlers from "./src/handlers/handlers.js";
-export { default as builtins } from "./src/project/builtins.js";
 export { default as coreGlobals } from "./src/project/coreGlobals.js";
 export { default as jsGlobals } from "./src/project/jsGlobals.js";
 export { default as projectConfig } from "./src/project/projectConfig.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.6",
+    "@weborigami/async-tree": "0.6.8",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/compiler/compile.js

@@ -6,6 +6,7 @@ function compile(source, options) {
   const { front, parent, startRule } = options;
   const mode = options.mode ?? "program";
   const globals = options.globals ?? {};
+
   if (typeof source === "string") {
     source = { text: source };
   }

package/src/compiler/origami.pegjs

@@ -853,8 +853,8 @@ relationalOperator
   / "<"
   / ">="
   / ">"
-  / "instanceof"
-  / "in"
+  / "instanceof" &[\s] // ensure `instanceof` is followed by whitespace
+  / "in" &[\s] // ensure `in` is followed by whitespace
 
 separator
   = __ "," __

package/src/compiler/parse.js

@@ -455,13 +455,14 @@ function peg$parse(input, options) {
   const peg$r15 = /^[0-7]/;
   const peg$r16 = /^[gimuy]/;
   const peg$r17 = /^[^\/\n\r]/;
-  const peg$r18 = /^[^\n\r]/;
-  const peg$r19 = /^[!+]/;
-  const peg$r20 = /^[\/)\]}]/;
-  const peg$r21 = /^[^\/,)\]}]/;
-  const peg$r22 = /^[a-z]/;
-  const peg$r23 = /^[a-z0-9+-.]/;
-  const peg$r24 = /^[:]/;
+  const peg$r18 = /^[s]/;
+  const peg$r19 = /^[^\n\r]/;
+  const peg$r20 = /^[!+]/;
+  const peg$r21 = /^[\/)\]}]/;
+  const peg$r22 = /^[^\/,)\]}]/;
+  const peg$r23 = /^[a-z]/;
+  const peg$r24 = /^[a-z0-9+-.]/;
+  const peg$r25 = /^[:]/;
 
   const peg$e0 = peg$literalExpectation("+", false);
   const peg$e1 = peg$literalExpectation("<", false);
@@ -566,32 +567,33 @@ function peg$parse(input, options) {
   const peg$e100 = peg$literalExpectation("<=", false);
   const peg$e101 = peg$literalExpectation(">=", false);
   const peg$e102 = peg$literalExpectation("instanceof", false);
-  const peg$e103 = peg$literalExpectation("in", false);
-  const peg$e104 = peg$literalExpectation("#!", false);
-  const peg$e105 = peg$classExpectation(["\n", "\r"], true, false, false);
-  const peg$e106 = peg$literalExpectation("<<", false);
-  const peg$e107 = peg$literalExpectation(">>>", false);
-  const peg$e108 = peg$literalExpectation(">>", false);
-  const peg$e109 = peg$otherExpectation("lambda function");
-  const peg$e110 = peg$literalExpectation("\u2192", false);
-  const peg$e111 = peg$literalExpectation("->", false);
-  const peg$e112 = peg$otherExpectation("single quote string");
-  const peg$e113 = peg$otherExpectation("string");
-  const peg$e114 = peg$literalExpectation("${", false);
-  const peg$e115 = peg$otherExpectation("template document");
-  const peg$e116 = peg$otherExpectation("template literal");
-  const peg$e117 = peg$otherExpectation("template substitution");
-  const peg$e118 = peg$classExpectation(["!", "+"], false, false, false);
-  const peg$e119 = peg$literalExpectation("~", false);
-  const peg$e120 = peg$classExpectation(["/", ")", "]", "}"], false, false, false);
-  const peg$e121 = peg$literalExpectation("await", false);
-  const peg$e122 = peg$literalExpectation("typeof", false);
-  const peg$e123 = peg$literalExpectation("void", false);
-  const peg$e124 = peg$classExpectation(["/", ",", ")", "]", "}"], true, false, false);
-  const peg$e125 = peg$otherExpectation("slash-separated path");
-  const peg$e126 = peg$classExpectation([["a", "z"]], false, false, false);
-  const peg$e127 = peg$classExpectation([["a", "z"], ["0", "9"], ["+", "."]], false, false, false);
-  const peg$e128 = peg$classExpectation([":"], false, false, false);
+  const peg$e103 = peg$classExpectation(["s"], false, false, false);
+  const peg$e104 = peg$literalExpectation("in", false);
+  const peg$e105 = peg$literalExpectation("#!", false);
+  const peg$e106 = peg$classExpectation(["\n", "\r"], true, false, false);
+  const peg$e107 = peg$literalExpectation("<<", false);
+  const peg$e108 = peg$literalExpectation(">>>", false);
+  const peg$e109 = peg$literalExpectation(">>", false);
+  const peg$e110 = peg$otherExpectation("lambda function");
+  const peg$e111 = peg$literalExpectation("\u2192", false);
+  const peg$e112 = peg$literalExpectation("->", false);
+  const peg$e113 = peg$otherExpectation("single quote string");
+  const peg$e114 = peg$otherExpectation("string");
+  const peg$e115 = peg$literalExpectation("${", false);
+  const peg$e116 = peg$otherExpectation("template document");
+  const peg$e117 = peg$otherExpectation("template literal");
+  const peg$e118 = peg$otherExpectation("template substitution");
+  const peg$e119 = peg$classExpectation(["!", "+"], false, false, false);
+  const peg$e120 = peg$literalExpectation("~", false);
+  const peg$e121 = peg$classExpectation(["/", ")", "]", "}"], false, false, false);
+  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$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);
+  const peg$e129 = peg$classExpectation([":"], false, false, false);
 
   function peg$f0() {
     return null;
@@ -6353,7 +6355,7 @@ function peg$parse(input, options) {
   }
 
   function peg$parserelationalOperator() {
-    let s0;
+    let s0, s1, s2, s3;
 
     if (input.substr(peg$currPos, 2) === peg$c59) {
       s0 = peg$c59;
@@ -6387,20 +6389,78 @@ function peg$parse(input, options) {
             if (peg$silentFails === 0) { peg$fail(peg$e3); }
           }
           if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
             if (input.substr(peg$currPos, 10) === peg$c61) {
-              s0 = peg$c61;
+              s1 = peg$c61;
               peg$currPos += 10;
             } else {
-              s0 = peg$FAILED;
+              s1 = peg$FAILED;
               if (peg$silentFails === 0) { peg$fail(peg$e102); }
             }
+            if (s1 !== peg$FAILED) {
+              s2 = peg$currPos;
+              peg$silentFails++;
+              s3 = input.charAt(peg$currPos);
+              if (peg$r18.test(s3)) {
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e103); }
+              }
+              peg$silentFails--;
+              if (s3 !== peg$FAILED) {
+                peg$currPos = s2;
+                s2 = undefined;
+              } else {
+                s2 = peg$FAILED;
+              }
+              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;
               if (input.substr(peg$currPos, 2) === peg$c62) {
-                s0 = peg$c62;
+                s1 = peg$c62;
                 peg$currPos += 2;
               } else {
+                s1 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$e104); }
+              }
+              if (s1 !== peg$FAILED) {
+                s2 = peg$currPos;
+                peg$silentFails++;
+                s3 = input.charAt(peg$currPos);
+                if (peg$r18.test(s3)) {
+                  peg$currPos++;
+                } else {
+                  s3 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$e103); }
+                }
+                peg$silentFails--;
+                if (s3 !== peg$FAILED) {
+                  peg$currPos = s2;
+                  s2 = undefined;
+                } else {
+                  s2 = peg$FAILED;
+                }
+                if (s2 !== peg$FAILED) {
+                  s1 = [s1, s2];
+                  s0 = s1;
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
                 s0 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e103); }
               }
             }
           }
@@ -6454,25 +6514,25 @@ function peg$parse(input, options) {
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e104); }
+      if (peg$silentFails === 0) { peg$fail(peg$e105); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r18.test(s3)) {
+      if (peg$r19.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e105); }
+        if (peg$silentFails === 0) { peg$fail(peg$e106); }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = input.charAt(peg$currPos);
-        if (peg$r18.test(s3)) {
+        if (peg$r19.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e105); }
+          if (peg$silentFails === 0) { peg$fail(peg$e106); }
         }
       }
       peg$savedPos = s0;
@@ -6559,7 +6619,7 @@ function peg$parse(input, options) {
       peg$currPos += 2;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e106); }
+      if (peg$silentFails === 0) { peg$fail(peg$e107); }
     }
     if (s0 === peg$FAILED) {
       if (input.substr(peg$currPos, 3) === peg$c65) {
@@ -6567,7 +6627,7 @@ function peg$parse(input, options) {
         peg$currPos += 3;
       } else {
         s0 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e107); }
+        if (peg$silentFails === 0) { peg$fail(peg$e108); }
       }
       if (s0 === peg$FAILED) {
         if (input.substr(peg$currPos, 2) === peg$c66) {
@@ -6575,7 +6635,7 @@ function peg$parse(input, options) {
           peg$currPos += 2;
         } else {
           s0 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e108); }
+          if (peg$silentFails === 0) { peg$fail(peg$e109); }
         }
       }
     }
@@ -6645,7 +6705,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e109); }
+      if (peg$silentFails === 0) { peg$fail(peg$e110); }
     }
 
     return s0;
@@ -6659,7 +6719,7 @@ function peg$parse(input, options) {
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e110); }
+      if (peg$silentFails === 0) { peg$fail(peg$e111); }
     }
     if (s0 === peg$FAILED) {
       if (input.substr(peg$currPos, 2) === peg$c68) {
@@ -6667,7 +6727,7 @@ function peg$parse(input, options) {
         peg$currPos += 2;
       } else {
         s0 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e111); }
+        if (peg$silentFails === 0) { peg$fail(peg$e112); }
       }
     }
 
@@ -6688,20 +6748,20 @@ function peg$parse(input, options) {
     if (s1 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r18.test(s3)) {
+      if (peg$r19.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e105); }
+        if (peg$silentFails === 0) { peg$fail(peg$e106); }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = input.charAt(peg$currPos);
-        if (peg$r18.test(s3)) {
+        if (peg$r19.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e105); }
+          if (peg$silentFails === 0) { peg$fail(peg$e106); }
         }
       }
       peg$savedPos = s0;
@@ -6748,7 +6808,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e112); }
+      if (peg$silentFails === 0) { peg$fail(peg$e113); }
     }
 
     return s0;
@@ -6921,7 +6981,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e113); }
+      if (peg$silentFails === 0) { peg$fail(peg$e114); }
     }
 
     return s0;
@@ -6975,7 +7035,7 @@ function peg$parse(input, options) {
       peg$currPos += 2;
     } else {
       s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e114); }
+      if (peg$silentFails === 0) { peg$fail(peg$e115); }
     }
     peg$silentFails--;
     if (s2 === peg$FAILED) {
@@ -7056,7 +7116,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e115); }
+      if (peg$silentFails === 0) { peg$fail(peg$e116); }
     }
 
     return s0;
@@ -7115,7 +7175,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e116); }
+      if (peg$silentFails === 0) { peg$fail(peg$e117); }
     }
 
     return s0;
@@ -7140,7 +7200,7 @@ function peg$parse(input, options) {
         peg$currPos += 2;
       } else {
         s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e114); }
+        if (peg$silentFails === 0) { peg$fail(peg$e115); }
       }
     }
     peg$silentFails--;
@@ -7193,7 +7253,7 @@ function peg$parse(input, options) {
       peg$currPos += 2;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e114); }
+      if (peg$silentFails === 0) { peg$fail(peg$e115); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$parseexpectExpression();
@@ -7223,7 +7283,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e117); }
+      if (peg$silentFails === 0) { peg$fail(peg$e118); }
     }
 
     return s0;
@@ -7276,11 +7336,11 @@ function peg$parse(input, options) {
     let s0, s1, s2, s3;
 
     s0 = input.charAt(peg$currPos);
-    if (peg$r19.test(s0)) {
+    if (peg$r20.test(s0)) {
       peg$currPos++;
     } else {
       s0 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e118); }
+      if (peg$silentFails === 0) { peg$fail(peg$e119); }
     }
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
@@ -7289,17 +7349,17 @@ function peg$parse(input, options) {
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e119); }
+        if (peg$silentFails === 0) { peg$fail(peg$e120); }
       }
       if (s1 !== peg$FAILED) {
         s2 = peg$currPos;
         peg$silentFails++;
         s3 = input.charAt(peg$currPos);
-        if (peg$r20.test(s3)) {
+        if (peg$r21.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e120); }
+          if (peg$silentFails === 0) { peg$fail(peg$e121); }
         }
         peg$silentFails--;
         if (s3 === peg$FAILED) {
@@ -7327,7 +7387,7 @@ function peg$parse(input, options) {
             peg$currPos += 5;
           } else {
             s1 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$e121); }
+            if (peg$silentFails === 0) { peg$fail(peg$e122); }
           }
           if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
@@ -7357,7 +7417,7 @@ function peg$parse(input, options) {
               peg$currPos += 6;
             } else {
               s1 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$e122); }
+              if (peg$silentFails === 0) { peg$fail(peg$e123); }
             }
             if (s1 !== peg$FAILED) {
               s2 = peg$currPos;
@@ -7387,7 +7447,7 @@ function peg$parse(input, options) {
                 peg$currPos += 4;
               } else {
                 s1 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$e123); }
+                if (peg$silentFails === 0) { peg$fail(peg$e124); }
               }
               if (s1 !== peg$FAILED) {
                 s2 = peg$currPos;
@@ -7563,11 +7623,11 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r21.test(s1)) {
+    if (peg$r22.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e124); }
+      if (peg$silentFails === 0) { peg$fail(peg$e125); }
     }
     if (s1 !== peg$FAILED) {
       s2 = peg$currPos;
@@ -7630,7 +7690,7 @@ function peg$parse(input, options) {
     peg$silentFails--;
     if (s0 === peg$FAILED) {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e125); }
+      if (peg$silentFails === 0) { peg$fail(peg$e126); }
     }
 
     return s0;
@@ -7641,37 +7701,37 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = input.charAt(peg$currPos);
-    if (peg$r22.test(s1)) {
+    if (peg$r23.test(s1)) {
       peg$currPos++;
     } else {
       s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$e126); }
+      if (peg$silentFails === 0) { peg$fail(peg$e127); }
     }
     if (s1 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r23.test(s3)) {
+      if (peg$r24.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e127); }
+        if (peg$silentFails === 0) { peg$fail(peg$e128); }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = input.charAt(peg$currPos);
-        if (peg$r23.test(s3)) {
+        if (peg$r24.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$e127); }
+          if (peg$silentFails === 0) { peg$fail(peg$e128); }
         }
       }
       s3 = input.charAt(peg$currPos);
-      if (peg$r24.test(s3)) {
+      if (peg$r25.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e128); }
+        if (peg$silentFails === 0) { peg$fail(peg$e129); }
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;

package/src/handlers/ori_handler.js

@@ -18,7 +18,7 @@ export default {
 
     // Compile the source code as an Origami program
     const compiler = options.compiler ?? compile.program;
-    const globals = options.globals ?? (await projectGlobals());
+    const globals = options.globals ?? (await projectGlobals(parent));
     const fn = compiler(source, {
       globals,
       mode: "program",

package/src/handlers/oridocument_handler.js

@@ -16,7 +16,7 @@ export default {
     const source = getSource(packed, options);
 
     // Compile the source code as an Origami template document
-    const globals = options.globals ?? (await projectGlobals());
+    const globals = options.globals ?? (await projectGlobals(parent));
     const defineFn = compile.templateDocument(source, {
       front: options.front,
       globals,

package/src/handlers/txt_handler.js

@@ -80,7 +80,7 @@ export default {
       const { body, frontText, isOrigami } = parsed;
       let frontData;
       if (isOrigami) {
-        const globals = await projectGlobals();
+        const globals = await projectGlobals(parent);
         const compiled = compile.expression(frontText.trim(), {
           globals,
           parent,

package/src/handlers/yaml_handler.js

@@ -98,7 +98,7 @@ export default {
 };
 
 async function oriCallTagForParent(parent, options, yaml) {
-  const globals = await projectGlobals();
+  const globals = await projectGlobals(parent);
   return {
     collection: "seq",
 
@@ -162,7 +162,7 @@ async function oriCallTagForParent(parent, options, yaml) {
 // Define the !ori tag for YAML parsing. This will run in the context of the
 // supplied parent.
 async function oriTagForParent(parent, options, yaml) {
-  const globals = await projectGlobals();
+  const globals = await projectGlobals(parent);
   return {
     resolve(text) {
       hasOriTags = true;

package/src/project/coreGlobals.js

@@ -1,17 +1,39 @@
 import { Tree } from "@weborigami/async-tree";
 import protocolGlobals from "../protocols/protocolGlobals.js";
 import * as protocols from "../protocols/protocols.js";
-import builtins from "./builtins.js";
 import jsGlobals from "./jsGlobals.js";
 
+let globals;
+
 export default async function coreGlobals() {
+  if (globals) {
+    return globals;
+  }
+
+  // Dynamic import to avoid circular dependency
   const handlerGlobals = await import("../handlers/handlers.js");
-  return {
+
+  let origamiBuiltins;
+  if (!origamiBuiltins) {
+    // This dynamic import is for a different reason. We want to load the
+    // Origami builtins if they're available, but not fail if they're not. This
+    // lets someone use the language package without installing the origami
+    // package. This arrangement is unorthodox but expedient.
+    try {
+      origamiBuiltins = await import("@weborigami/origami");
+    } catch {
+      origamiBuiltins = {};
+    }
+  }
+
+  globals = {
     ...jsGlobals,
     Tree,
     Protocol: protocols,
     ...protocolGlobals,
     ...handlerGlobals,
-    ...builtins,
+    ...origamiBuiltins,
   };
+
+  return globals;
 }

package/src/project/projectConfig.js

@@ -1,23 +1,20 @@
-import { FileMap, toString } from "@weborigami/async-tree";
+import { toString, Tree } from "@weborigami/async-tree";
 import ori_handler from "../handlers/ori_handler.js";
 import coreGlobals from "./coreGlobals.js";
-import projectRootFromPath from "./projectRootFromPath.js";
 
-const mapPathToConfig = new Map();
+/**
+ * Given a container, return the Origami configuration for the associated
+ * project root. This will be the unpacked config.ori file if it exists, or an
+ * empty object otherwise.
+ *
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
+ * @param {SyncOrAsyncMap} parent
+ */
+export default async function config(parent) {
+  const projectRoot = await Tree.root(parent);
 
-export default async function config(dir = process.cwd()) {
-  const root = await projectRootFromPath(dir);
-
-  const rootPath = root.path;
-  const cached = mapPathToConfig.get(rootPath);
-  if (cached) {
-    return cached;
-  }
-
-  // Use a plain FileMap to avoid loading extension handlers
-  const rootFileMap = new FileMap(rootPath);
-  const configBuffer = await rootFileMap.get("config.ori");
   let configObject = {};
+  const configBuffer = await projectRoot.get("config.ori");
   if (configBuffer) {
     const configText = toString(configBuffer);
     if (configText) {
@@ -26,11 +23,10 @@ export default async function config(dir = process.cwd()) {
       // Evaluate the config file to obtain the configuration object
       configObject = await ori_handler.unpack(configText, {
         globals,
-        parent: root,
+        parent: projectRoot,
       });
     }
   }
 
-  mapPathToConfig.set(rootPath, configObject);
   return configObject;
 }

package/src/project/projectGlobals.js

@@ -1,19 +1,43 @@
+import { Tree } from "@weborigami/async-tree";
+import assignPropertyDescriptors from "../runtime/assignPropertyDescriptors.js";
 import coreGlobals from "./coreGlobals.js";
 import projectConfig from "./projectConfig.js";
 
-let globals;
+/**
+ * Return the complete set of globals available to code running in the given
+ * container. This will be the core globals plus any configuration specified in
+ * the project's config.ori file.
+ *
+ * This destructively caches a `globals` property on the root of the given
+ * container.
+ *
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
+ * @param {SyncOrAsyncMap|null} parent
+ */
+export default async function projectGlobals(parent) {
+  if (!parent) {
+    return coreGlobals();
+  }
 
-// Core globals plus project config
-export default async function projectGlobals(dir = process.cwd()) {
-  if (!globals) {
+  const projectRoot = await Tree.root(parent);
+  if (!projectRoot.globals) {
     // Start with core globals
-    globals = await coreGlobals();
-    // Now get config. The config.ori file may require access to globals,
-    // which will obtain the core globals set above. Once we've got the
-    // config, we add it to the globals.
-    const config = await projectConfig(dir);
-    Object.assign(globals, config);
+    const globals = await coreGlobals();
+
+    if (parent) {
+      // Get config for the given container and add it to the globals. During
+      // this read, we want to only rely on core globals to avoid circularities,
+      // so we temporarily set globals to coreGlobals.
+      projectRoot.globals = globals;
+      const config = await projectConfig(parent);
+
+      // Merge config into globals; don't invoke property getters.
+      assignPropertyDescriptors(globals, config);
+    }
+
+    // Cache globals on project root
+    projectRoot.globals = globals;
   }
 
-  return globals;
+  return projectRoot.globals;
 }

package/src/project/projectRoot.js

@@ -4,6 +4,6 @@ import { Tree } from "@weborigami/async-tree";
  * Return an OrigamiFileMap object for the current code context.
  */
 export default async function projectRoot(state) {
-  return Tree.root(state.container);
+  return Tree.root(state.parent);
 }
 projectRoot.needsState = true;

package/src/project/projectRootFromPath.js

@@ -5,54 +5,55 @@ import OrigamiFileMap from "../runtime/OrigamiFileMap.js";
 const configFileName = "config.ori";
 const packageFileName = "package.json";
 
-const mapPathToRoot = new Map();
-
 /**
- * Return an OrigamiFileMap object for the current project root.
- *
- * This searches the current directory and its ancestors for an Origami file
- * called `config.ori`. If an Origami configuration file is found, the
- * containing folder is considered to be the project root.
+ * Return an OrigamiFileMap object for the given folder.
  *
- * Otherwise, this looks for a package.json file to determine the project root.
- * If no package.json is found, the current folder is used as the project root.
+ * This searches the given folder and its ancestors for an Origami file called
+ * `config.ori`. If an Origami configuration file is found, the containing
+ * folder is considered to be the project root.
  *
+ * Otherwise this looks for a package.json file to determine the project root.
+ * If none is found, the given folder itself is used as the project root.
  *
- * @param {string} [dirname]
+ * @param {string} dirname
  */
-export default async function projectRootFromPath(dirname = process.cwd()) {
-  const cached = mapPathToRoot.get(dirname);
-  if (cached) {
-    return cached;
-  }
-
+export default async function projectRootFromPath(dirname) {
   let root;
   let value;
   // Use a plain FileMap to avoid loading extension handlers
-  const currentTree = new FileMap(dirname);
-  // Try looking for config file
-  value = await currentTree.get(configFileName);
-  if (value) {
-    // Found config file
-    root = new OrigamiFileMap(currentTree.path);
-  } else {
+  let currentFolder = new FileMap(dirname);
+  while (currentFolder) {
+    // Try looking for config file
+    value = await currentFolder.get(configFileName);
+    if (value) {
+      // Found config file
+      root = new OrigamiFileMap(currentFolder.path);
+      break;
+    }
+
     // Try looking for package.json
-    value = await currentTree.get(packageFileName);
+    value = await currentFolder.get(packageFileName);
     if (value) {
       // Found package.json
-      root = new OrigamiFileMap(currentTree.path);
+      root = new OrigamiFileMap(currentFolder.path);
+      break;
+    }
+
+    // Move up a folder and try again
+    const parentPath = path.dirname(currentFolder.path);
+    if (parentPath !== currentFolder.path) {
+      currentFolder = new FileMap(parentPath);
     } else {
-      // Move up a folder and try again
-      const parentPath = path.dirname(dirname);
-      if (parentPath !== dirname) {
-        root = await projectRootFromPath(parentPath);
-      } else {
-        // At filesystem root, use current working directory
-        root = new OrigamiFileMap(process.cwd());
-      }
+      // At filesystem root; not found
+      root = null;
+      break;
     }
   }
 
-  mapPathToRoot.set(dirname, root);
+  if (!root) {
+    // Default to using the provided folder as the project root
+    root = new OrigamiFileMap(dirname);
+  }
+
   return root;
 }

package/src/protocols/fetchAndHandleExtension.js

@@ -3,10 +3,12 @@ import handleExtension from "../runtime/handleExtension.js";
 /**
  * Fetch the resource at the given href.
  *
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
  *
  * @param {string} href
+ * @param {SyncOrAsyncMap} parent
  */
-export default async function fetchAndHandleExtension(href) {
+export default async function fetchAndHandleExtension(href, parent) {
   const response = await fetch(href);
   if (!response.ok) {
     return undefined;
@@ -22,7 +24,7 @@ export default async function fetchAndHandleExtension(href) {
   const url = new URL(href);
   const filename = url.pathname.split("/").pop();
   if (filename) {
-    buffer = await handleExtension(buffer, filename);
+    buffer = await handleExtension(buffer, filename, parent);
   }
 
   return buffer;

package/src/protocols/files.js

@@ -1,25 +1,27 @@
 import os from "node:os";
 import path from "node:path";
-import process from "node:process";
 import OrigamiFileMap from "../runtime/OrigamiFileMap.js";
 
 /**
  *
- * @param {string[]} keys
+ * @param {any[]} args
  */
-export default async function files(...keys) {
+export default async function files(...args) {
+  const state = args.pop(); // Remaining args are the path
+
   // If path begins with `~`, treat it relative to the home directory.
-  // Otherwise, treat it relative to the current working directory.
-  let relativePath = keys.join(path.sep);
+  // Otherwise, treat it relative to the current container.
+  let relativePath = args.join(path.sep);
   let basePath;
   if (relativePath.startsWith("~")) {
     basePath = os.homedir();
     relativePath = relativePath.slice(2);
   } else {
-    basePath = process.cwd();
+    basePath = state.parent.path;
   }
   const resolved = path.resolve(basePath, relativePath);
 
   const result = new OrigamiFileMap(resolved);
   return result;
 }
+files.needsState = true;

package/src/protocols/http.js

@@ -6,9 +6,11 @@ import fetchAndHandleExtension from "./fetchAndHandleExtension.js";
  *
  *
  * @param {string} host
- * @param  {...string} keys
+ * @param  {...any} keys
  */
 export default async function http(host, ...keys) {
+  const state = keys.pop();
   const href = constructHref("http:", host, ...keys);
-  return fetchAndHandleExtension(href);
+  return fetchAndHandleExtension(href, state.parent);
 }
+http.needsState = true;

package/src/protocols/https.js

@@ -6,9 +6,11 @@ import fetchAndHandleExtension from "./fetchAndHandleExtension.js";
  *
  *
  * @param {string} host
- * @param  {...string} keys
+ * @param  {...any} keys
  */
 export default async function https(host, ...keys) {
+  const state = keys.pop();
   const href = constructHref("https:", host, ...keys);
-  return fetchAndHandleExtension(href);
+  return fetchAndHandleExtension(href, state.parent);
 }
+https.needsState = true;

package/src/runtime/WatchFilesMixin.js

@@ -1,5 +1,4 @@
-import * as fs from "node:fs/promises";
-import path from "node:path";
+import * as fs from "node:fs";
 import Watcher from "watcher";
 import TreeEvent from "./TreeEvent.js";
 
@@ -15,10 +14,10 @@ export default function WatchFilesMixin(Base) {
       }
     }
 
-    onChange(key) {
+    onChange(filePath) {
       // Reset cached values.
       this.subfoldersMap = new Map();
-      this.dispatchEvent(new TreeEvent("change", { key }));
+      this.dispatchEvent(new TreeEvent("change", { filePath }));
     }
 
     async unwatch() {
@@ -38,7 +37,7 @@ export default function WatchFilesMixin(Base) {
       this.watching = true;
 
       // Ensure the directory exists.
-      await fs.mkdir(this.dirname, { recursive: true });
+      fs.mkdirSync(this.dirname, { recursive: true });
 
       this.watcher = new Watcher(this.dirname, {
         ignoreInitial: true,
@@ -46,8 +45,7 @@ export default function WatchFilesMixin(Base) {
         recursive: true,
       });
       this.watcher.on("all", (event, filePath) => {
-        const key = path.basename(filePath);
-        this.onChange(key);
+        this.onChange(filePath);
       });
 
       // Add to the list of FileTree instances watching this directory.

package/src/runtime/assignPropertyDescriptors.js

@@ -0,0 +1,23 @@
+/**
+ * This is an analogue of Object.assign that destructively copies properties to
+ * a target object -- but avoids invoking property getters. Instead, it copies
+ * property descriptors over to the target object.
+ *
+ * @param {any} target
+ * @param  {...any} sources
+ */
+export default function assignPropertyDescriptors(target, ...sources) {
+  for (const source of sources) {
+    const descriptors = Object.getOwnPropertyDescriptors(source);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (descriptor.value !== undefined) {
+        // Simple value, copy it
+        target[key] = descriptor.value;
+      } else {
+        // Getter and/or setter, copy the descriptor
+        Object.defineProperty(target, key, descriptor);
+      }
+    }
+  }
+  return target;
+}

package/src/runtime/evaluate.js

@@ -24,7 +24,7 @@ export default async function evaluate(code, state = {}) {
   } else {
     // Evaluate each instruction in the code.
     evaluated = await Promise.all(
-      code.map((instruction) => evaluate(instruction, state))
+      code.map((instruction) => evaluate(instruction, state)),
     );
   }
 
@@ -34,7 +34,7 @@ export default async function evaluate(code, state = {}) {
   if (!fn) {
     // The code wants to invoke something that's couldn't be found in scope.
     const error = ReferenceError(
-      `${codeFragment(code[0].location)} is not defined`
+      `${codeFragment(code[0].location)} is not defined`,
     );
     /** @type {any} */ (error).location = code[0].location;
     throw error;
@@ -48,9 +48,9 @@ export default async function evaluate(code, state = {}) {
   if (fn.needsState) {
     // The function is an op that wants the runtime state
     args.push(state);
-  } else if (fn.containerAsTarget && state.container) {
+  } else if (fn.containerAsTarget && state.parent) {
     // The function wants the code's container as the `this` target
-    fn = fn.bind(state.container);
+    fn = fn.bind(state.parent);
   }
 
   // Execute the function or traverse the tree.

package/src/runtime/expressionFunction.js

@@ -10,9 +10,7 @@ import { evaluate } from "./internal.js";
  */
 export function createExpressionFunction(code, parent) {
   async function fn() {
-    return evaluate(code, {
-      container: parent,
-    });
+    return evaluate(code, { parent });
   }
   fn.code = code;
   fn.toString = () => code.location.source.text;

package/src/runtime/expressionObject.js

@@ -138,6 +138,9 @@ function defineProperty(object, propertyInfo, state, map) {
  * Return a normalized version of the property key for use in the keys() method.
  * Among other things, this adds trailing slashes to keys that correspond to
  * maplike values.
+ *
+ * @param {any} propertyInfo
+ * @param {object|null} [object]
  */
 export function normalizeKey(propertyInfo, object = null) {
   const { key, value, valueType } = propertyInfo;

package/src/runtime/handleExtension.js

@@ -7,9 +7,7 @@ import {
   setParent,
   trailingSlash,
 } from "@weborigami/async-tree";
-import globals from "../project/projectGlobals.js";
-
-let projectGlobals;
+import projectGlobals from "../project/projectGlobals.js";
 
 /**
  * If the given value is packed (e.g., buffer) and the key is a string-like path
@@ -18,9 +16,9 @@ let projectGlobals;
  *
  * @param {any} value
  * @param {any} key
- * @param {import("@weborigami/async-tree").SyncOrAsyncMap} [parent]
+ * @param {import("@weborigami/async-tree").SyncOrAsyncMap|null} [parent]
  */
-export default async function handleExtension(value, key, parent) {
+export default async function handleExtension(value, key, parent = null) {
   if (isPacked(value) && isStringlike(key) && value.unpack === undefined) {
     const hasSlash = trailingSlash.has(key);
     if (hasSlash) {
@@ -33,7 +31,7 @@ export default async function handleExtension(value, key, parent) {
       : extension.extname(key);
     if (extname) {
       const handlerName = `${extname.slice(1)}_handler`;
-      const handlers = await getHandlers(parent);
+      const handlers = await projectGlobals(parent);
       let handler = await handlers[handlerName];
       if (handler) {
         if (isUnpackable(handler)) {
@@ -66,19 +64,3 @@ export default async function handleExtension(value, key, parent) {
   }
   return value;
 }
-
-async function getHandlers(parent) {
-  // Walk up the parent chain to find first `handlers` property
-  let current = parent;
-
-  while (current) {
-    if (current.handlers) {
-      return current.handlers;
-    }
-    current = current.parent;
-  }
-
-  // Fall back to project globals
-  projectGlobals ??= await globals();
-  return projectGlobals;
-}

package/src/runtime/mergeTrees.js

@@ -1,4 +1,5 @@
 import { isPlainObject, isUnpackable, Tree } from "@weborigami/async-tree";
+import assignPropertyDescriptors from "./assignPropertyDescriptors.js";
 
 /**
  * Create a tree that's the result of merging the given trees.
@@ -21,26 +22,14 @@ export default async function mergeTrees(...trees) {
   // Unpack any packed objects.
   const unpacked = await Promise.all(
     filtered.map((obj) =>
-      isUnpackable(obj) ? /** @type {any} */ (obj).unpack() : obj
-    )
+      isUnpackable(obj) ? /** @type {any} */ (obj).unpack() : obj,
+    ),
   );
 
   // If all trees are plain objects, return a plain object.
   if (unpacked.every((tree) => isPlainObject(tree) && !Tree.isMap(tree))) {
-    // If we do an Object.assign, we'd evaluate getters.
-    // To avoid that, we'll merge property descriptors.
-    const result = {};
-    for (const obj of unpacked) {
-      const descriptors = Object.getOwnPropertyDescriptors(obj);
-      for (const [key, descriptor] of Object.entries(descriptors)) {
-        if (descriptor.value !== undefined) {
-          result[key] = descriptor.value;
-        } else {
-          Object.defineProperty(result, key, descriptor);
-        }
-      }
-    }
-    return result;
+    // Use our Object.assign variation that avoids invoking property getters.
+    return assignPropertyDescriptors({}, ...unpacked);
   }
 
   // Merge the trees.

package/test/project/projectConfig.test.js

@@ -1,28 +1,26 @@
+import { FileMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import { fileURLToPath } from "node:url";
 import projectConfig from "../../src/project/projectConfig.js";
 
 describe("projectConfig", () => {
-  test("finds Origami configuration file", async () => {
-    // Find the folder that represents the project root.
-    const projectUrl = new URL("fixtures/withConfig/", import.meta.url);
-    // Find subfolder inside project root.
-    const subfolderUrl = new URL("./subfolder/", projectUrl);
-    const subfolderPath = fileURLToPath(subfolderUrl);
-
-    const config = await projectConfig(subfolderPath);
+  test("loads Origami configuration file if present", async () => {
+    // The folder that represents the project root
+    const projectFiles = new FileMap(
+      new URL("fixtures/withConfig/", import.meta.url),
+    );
+    const subfolder = await projectFiles.get("subfolder");
+    const config = await projectConfig(subfolder);
     assert.equal(config.message, "Hello");
   });
 
   test("defaults to an empty object", async () => {
-    // Find the folder that represents the project root.
-    const projectUrl = new URL("fixtures/withPackageJson/", import.meta.url);
-    // Find subfolder inside project root.
-    const subfolderUrl = new URL("./subfolder/", projectUrl);
-    const subfolderPath = fileURLToPath(subfolderUrl);
-
-    const config = await projectConfig(subfolderPath);
+    // The folder that represents the project root
+    const projectFiles = new FileMap(
+      new URL("fixtures/withPackageJson/", import.meta.url),
+    );
+    const subfolder = await projectFiles.get("subfolder");
+    const config = await projectConfig(subfolder);
     assert.deepEqual(config, {});
   });
 });

package/test/project/projectRootFromPath.test.js

@@ -33,8 +33,8 @@ describe("projectRootFromPath", () => {
     assert.equal(resultPath, fileURLToPath(projectUrl));
   });
 
-  test("defaults to current working directory", async () => {
+  test("defaults to supplied directory", async () => {
     const root = await projectRootFromPath("/");
-    assert.equal(root.path, process.cwd());
+    assert.equal(root.path, "/");
   });
 });

package/test/protocols/package.test.js

@@ -1,4 +1,5 @@
 import assert from "node:assert";
+import process from "node:process";
 import { describe, test } from "node:test";
 import projectRootFromPath from "../../src/project/projectRootFromPath.js";
 import packageProtocol from "../../src/protocols/package.js";
@@ -6,10 +7,10 @@ import packageProtocol from "../../src/protocols/package.js";
 describe("package: protocol", () => {
   test("returns a package's main export(s)", async () => {
     // Reproduce the type of evaluation context object the runtime would create
-    const projectRoot = await projectRootFromPath();
-    const context = { container: projectRoot };
+    const projectRoot = await projectRootFromPath(process.cwd());
+    const state = { parent: projectRoot };
 
-    const result = await packageProtocol("@weborigami", "async-tree", context);
+    const result = await packageProtocol("@weborigami", "async-tree", state);
     const { toString } = result;
     assert.equal(toString(123), "123");
   });

package/test/runtime/evaluate.test.js

@@ -32,10 +32,10 @@ describe("evaluate", () => {
       return this;
     };
     fn.containerAsTarget = true;
-    const container = new SyncMap();
-    const state = { container };
+    const parent = new SyncMap();
+    const state = { parent };
     const code = createCode([fn]);
     const result = await evaluate(code, state);
-    assert.equal(result, container);
+    assert.equal(result, parent);
   });
 });

package/src/project/builtins.js

@@ -1,5 +0,0 @@
-/**
- * Consumers of the compiler (e.g., the Origami CLI) should inject their own
- * builtin functions into this object.
- */
-export default {};