@weborigami/language 0.5.8 → 0.6.0

package/index.ts

@@ -1,5 +1,4 @@
-import { UnpackFunction } from "@weborigami/async-tree";
-import { AsyncTree } from "@weborigami/types";
+import { SyncOrAsyncMap, UnpackFunction } from "@weborigami/async-tree";
 
 export * from "./main.js";
 
@@ -59,9 +58,9 @@ export type Position = {
 
 export type RuntimeState = {
   /** The container (e.g., file system) that holds the code */
-  container?: AsyncTree | null;
+  container?: SyncOrAsyncMap | null;
   /** The object to which this code is attached */
-  object?: AsyncTree | null;
+  object?: SyncOrAsyncMap | null;
   /** The current stack of function parameter assignments */
   stack?: Array<Record<string, any>>;
 }

package/main.js

@@ -12,14 +12,12 @@ export { formatError } from "./src/runtime/errors.js";
 export { default as evaluate } from "./src/runtime/evaluate.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
 export * as expressionFunction from "./src/runtime/expressionFunction.js";
-export { default as functionResultsMap } from "./src/runtime/functionResultsMap.js";
 export * from "./src/runtime/handleExtension.js";
 export { default as handleExtension } from "./src/runtime/handleExtension.js";
 export { default as HandleExtensionsTransform } from "./src/runtime/HandleExtensionsTransform.js";
 export { default as ImportModulesMixin } from "./src/runtime/ImportModulesMixin.js";
-export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctionsTransform.js";
 export * as moduleCache from "./src/runtime/moduleCache.js";
-export { default as OrigamiFiles } from "./src/runtime/OrigamiFiles.js";
+export { default as OrigamiFileMap } from "./src/runtime/OrigamiFileMap.js";
 export * as symbols from "./src/runtime/symbols.js";
 export { default as TreeEvent } from "./src/runtime/TreeEvent.js";
 export { default as WatchFilesMixin } from "./src/runtime/WatchFilesMixin.js";

package/package.json

@@ -1,18 +1,17 @@
 {
   "name": "@weborigami/language",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "24.3.0",
+    "@types/node": "24.10.1",
     "peggy": "5.0.6",
-    "typescript": "5.9.2"
+    "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.5.8",
-    "@weborigami/types": "0.5.8",
+    "@weborigami/async-tree": "0.6.0",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/handlers/csv_handler.js

@@ -34,11 +34,21 @@ function csvParse(text) {
   const rows = [];
   let currentRow = [];
   let currentField = "";
+  let wasQuoted = false; // True if the current field was quoted
 
   const pushField = () => {
-    // Push the completed field and reset for the next field.
-    currentRow.push(currentField);
+    /** @type {string|number} */
+    let parsedField = currentField;
+    if (!wasQuoted) {
+      // Field wasn't quoted: if it's a valid number, convert it
+      const n = Number(currentField);
+      if (!isNaN(n)) {
+        parsedField = n;
+      }
+    }
+    currentRow.push(parsedField);
     currentField = "";
+    wasQuoted = false; // Reset the flag for the next field
   };
 
   const pushRow = () => {
@@ -54,29 +64,24 @@ function csvParse(text) {
     const char = text[i];
 
     if (inQuotes) {
-      // In a quoted field
       if (char === '"') {
-        // Check if next character is also a quote
         if (i + 1 < text.length && text[i + 1] === '"') {
-          // Append a literal double quote and skip the next character
           currentField += '"';
           i += 2;
           continue;
         } else {
-          // End of the quoted field
           inQuotes = false;
           i++;
           continue;
         }
       } else {
-        // All other characters within quotes are taken literally.
         currentField += char;
         i++;
         continue;
       }
     } else if (char === '"') {
-      // Start of a quoted field
       inQuotes = true;
+      wasQuoted = true; // Mark the field as quoted
       i++;
       continue;
     } else if (char === ",") {

package/src/handlers/tsv_handler.js

@@ -45,7 +45,16 @@ function tsvParse(text) {
     const values = lines[i].split("\t");
     const entry = {};
     for (let j = 0; j < headers.length; j++) {
-      entry[headers[j]] = values[j] ?? "";
+      /** @type {string|number} */
+      let value = values[j];
+      if (value !== undefined) {
+        // Attempt to convert to number if possible
+        const n = Number(value);
+        if (!isNaN(n)) {
+          value = n;
+        }
+      }
+      entry[headers[j]] = value ?? "";
     }
     data.push(entry);
   }

package/src/project/jsGlobals.js

@@ -168,7 +168,11 @@ async function fetchWrapper(resource, options) {
   return response.ok ? await response.arrayBuffer() : undefined;
 }
 
-/** @this {import("@weborigami/types").AsyncTree|null|undefined} */
+/**
+ * @typedef {import("@weborigami/async-tree").AsyncMap} AsyncMap
+ *
+ * @this {AsyncMap|null|undefined}
+ */
 async function importWrapper(modulePath) {
   // Walk up parent tree looking for a FileTree or other object with a `path`
   /** @type {any} */

package/src/project/projectConfig.js

@@ -1,4 +1,4 @@
-import { FileTree, toString } from "@weborigami/async-tree";
+import { FileMap, toString } from "@weborigami/async-tree";
 import ori_handler from "../handlers/ori_handler.js";
 import coreGlobals from "./coreGlobals.js";
 import projectRoot from "./projectRoot.js";
@@ -14,9 +14,9 @@ export default async function config(dir = process.cwd()) {
     return cached;
   }
 
-  // Use a plain FileTree to avoid loading extension handlers
-  const rootFileTree = new FileTree(rootPath);
-  const configBuffer = await rootFileTree.get("config.ori");
+  // Use a plain FileMap to avoid loading extension handlers
+  const rootFileMap = new FileMap(rootPath);
+  const configBuffer = await rootFileMap.get("config.ori");
   let configObject = {};
   if (configBuffer) {
     const configText = toString(configBuffer);

package/src/project/projectRoot.js

@@ -1,6 +1,6 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import path from "node:path";
-import OrigamiFiles from "../runtime/OrigamiFiles.js";
+import OrigamiFileMap from "../runtime/OrigamiFileMap.js";
 
 const configFileName = "config.ori";
 const packageFileName = "package.json";
@@ -8,7 +8,7 @@ const packageFileName = "package.json";
 const mapPathToRoot = new Map();
 
 /**
- * Return an OrigamiFiles object for the current project.
+ * Return an OrigamiFileMap object for the current project.
  *
  * This searches the current directory and its ancestors for an Origami file
  * called `config.ori`. If an Origami configuration file is found, the
@@ -17,7 +17,6 @@ const mapPathToRoot = new Map();
  * 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.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} [dirname]
  */
@@ -29,19 +28,19 @@ export default async function projectRoot(dirname = process.cwd()) {
 
   let root;
   let value;
-  // Use a plain FileTree to avoid loading extension handlers
-  const currentTree = new FileTree(dirname);
+  // 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 OrigamiFiles(currentTree.path);
+    root = new OrigamiFileMap(currentTree.path);
   } else {
     // Try looking for package.json
     value = await currentTree.get(packageFileName);
     if (value) {
       // Found package.json
-      root = new OrigamiFiles(currentTree.path);
+      root = new OrigamiFileMap(currentTree.path);
     } else {
       // Move up a folder and try again
       const parentPath = path.dirname(dirname);
@@ -49,7 +48,7 @@ export default async function projectRoot(dirname = process.cwd()) {
         root = await projectRoot(parentPath);
       } else {
         // At filesystem root, use current working directory
-        root = new OrigamiFiles(process.cwd());
+        root = new OrigamiFileMap(process.cwd());
       }
     }
   }

package/src/protocols/constructSiteTree.js

@@ -5,14 +5,14 @@ import constructHref from "./constructHref.js";
 /**
  * Given a protocol, a host, and a list of keys, construct an href.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
  *
  * @param {string} protocol
- * @param {import("../../index.ts").Constructor<AsyncTree>} treeClass
+ * @param {import("../../index.ts").Constructor<SyncOrAsyncMap>} mapClass
  * @param {string} host
  * @param  {string[]} keys
  */
-export default function constructSiteTree(protocol, treeClass, host, ...keys) {
+export default function constructSiteTree(protocol, mapClass, host, ...keys) {
   // If the last key doesn't end in a slash, remove it for now.
   let lastKey;
   if (keys.length > 0 && keys.at(-1) && !trailingSlash.has(keys.at(-1))) {
@@ -20,7 +20,7 @@ export default function constructSiteTree(protocol, treeClass, host, ...keys) {
   }
 
   const href = constructHref(protocol, host, ...keys);
-  let result = new (HandleExtensionsTransform(treeClass))(href);
+  let result = new (HandleExtensionsTransform(mapClass))(href);
 
   return lastKey ? result.get(lastKey) : result;
 }

package/src/protocols/explore.js

@@ -1,14 +1,13 @@
-import { ExplorableSiteTree } from "@weborigami/async-tree";
+import { ExplorableSiteMap } from "@weborigami/async-tree";
 import constructSiteTree from "./constructSiteTree.js";
 
 /**
  * A site tree with JSON Keys via HTTPS.
  *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} host
  * @param  {...string} keys
  */
 export default function explore(host, ...keys) {
-  return constructSiteTree("https:", ExplorableSiteTree, host, ...keys);
+  return constructSiteTree("https:", ExplorableSiteMap, host, ...keys);
 }

package/src/protocols/fetchAndHandleExtension.js

@@ -3,7 +3,6 @@ import handleExtension from "../runtime/handleExtension.js";
 /**
  * Fetch the resource at the given href.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} href
  */

package/src/protocols/files.js

@@ -1,10 +1,9 @@
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import OrigamiFiles from "../runtime/OrigamiFiles.js";
+import OrigamiFileMap from "../runtime/OrigamiFileMap.js";
 
 /**
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string[]} keys
  */
@@ -21,6 +20,6 @@ export default async function files(...keys) {
   }
   const resolved = path.resolve(basePath, relativePath);
 
-  const result = new OrigamiFiles(resolved);
+  const result = new OrigamiFileMap(resolved);
   return result;
 }

package/src/protocols/http.js

@@ -4,7 +4,6 @@ import fetchAndHandleExtension from "./fetchAndHandleExtension.js";
 /**
  * Retrieve the indicated web resource via HTTP.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} host
  * @param  {...string} keys

package/src/protocols/https.js

@@ -4,7 +4,6 @@ import fetchAndHandleExtension from "./fetchAndHandleExtension.js";
 /**
  * Retrieve the indicated web resource via HTTPS.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} host
  * @param  {...string} keys

package/src/protocols/httpstree.js

@@ -1,14 +1,13 @@
-import { SiteTree } from "@weborigami/async-tree";
+import { SiteMap } from "@weborigami/async-tree";
 import constructSiteTree from "./constructSiteTree.js";
 
 /**
  * Return a website tree via HTTPS.
  *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} host
  * @param  {...string} keys
  */
 export default function httpstree(host, ...keys) {
-  return constructSiteTree("https:", SiteTree, host, ...keys);
+  return constructSiteTree("https:", SiteMap, host, ...keys);
 }

package/src/protocols/httptree.js

@@ -1,14 +1,13 @@
-import { SiteTree } from "@weborigami/async-tree";
+import { SiteMap } from "@weborigami/async-tree";
 import constructSiteTree from "./constructSiteTree.js";
 
 /**
  * Return a website tree via HTTP.
  *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} host
  * @param  {...string} keys
  */
 export default function httptree(host, ...keys) {
-  return constructSiteTree("http:", SiteTree, host, ...keys);
+  return constructSiteTree("http:", SiteMap, host, ...keys);
 }

package/src/runtime/HandleExtensionsTransform.js

@@ -1,17 +1,41 @@
 import handleExtension from "./handleExtension.js";
 
 /**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.ts").Constructor<AsyncTree>} AsyncTreeConstructor
+ * @typedef {import("../../index.ts").Constructor<Map>} MapConstructor
  * @typedef {import("@weborigami/async-tree").UnpackFunction} FileUnpackFunction
  *
- * @param {AsyncTreeConstructor} Base
+ * @param {MapConstructor} Base
  */
 export default function HandleExtensionsTransform(Base) {
-  return class HandleExtensions extends Base {
-    async get(key) {
-      const value = await super.get(key);
-      return handleExtension(value, key, this);
+  class HandleExtensions extends Base {
+    // Implement delete (and set) to keep the Map read-write
+    delete(key) {
+      return super.delete(key);
     }
-  };
+
+    get(key) {
+      const value = super.get(key);
+      return value instanceof Promise
+        ? value.then((resolved) => handleExtension(resolved, key, this))
+        : handleExtension(value, key, this);
+    }
+
+    // See delete()
+    set(key, value) {
+      return super.set(key, value);
+    }
+  }
+
+  if (Base.prototype.readOnly) {
+    // Remove delete and set methods to keep the Map read-only. The base delete
+    // and set methods will exist (because it's a Map) but for our purposes the
+    // class is read-only.
+
+    // @ts-ignore
+    delete HandleExtensions.prototype.delete;
+    // @ts-ignore
+    delete HandleExtensions.prototype.set;
+  }
+
+  return HandleExtensions;
 }

package/src/runtime/ImportModulesMixin.js

@@ -5,8 +5,8 @@ import { maybeOrigamiSourceCode } from "./errors.js";
 import * as moduleCache from "./moduleCache.js";
 
 /**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.ts").Constructor<AsyncTree & { dirname: string }>} BaseConstructor
+ * @typedef {import("@weborigami/async-tree").AsyncMap} AsyncMap
+ * @typedef {import("../../index.ts").Constructor<AsyncMap & { dirname: string }>} BaseConstructor
  * @param {BaseConstructor} Base
  */
 export default function ImportModulesMixin(Base) {

package/src/runtime/{OrigamiFiles.js → OrigamiFileMap.d.ts}

@@ -1,9 +1,9 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import EventTargetMixin from "./EventTargetMixin.js";
 import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import ImportModulesMixin from "./ImportModulesMixin.js";
 import WatchFilesMixin from "./WatchFilesMixin.js";
 
-export default class OrigamiFiles extends HandleExtensionsTransform(
-  ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileTree)))
+export default class OrigamiFileMap extends HandleExtensionsTransform(
+  ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileMap)))
 ) {}

package/src/runtime/{OrigamiFiles.d.ts → OrigamiFileMap.js}

@@ -1,11 +1,9 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import EventTargetMixin from "./EventTargetMixin.js";
 import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import ImportModulesMixin from "./ImportModulesMixin.js";
 import WatchFilesMixin from "./WatchFilesMixin.js";
 
-export default class OrigamiFiles extends HandleExtensionsTransform(
-  (
-    ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileTree)))
-  )
+export default class OrigamiFileMap extends HandleExtensionsTransform(
+  ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileMap)))
 ) {}

package/src/runtime/expressionFunction.js

@@ -1,12 +1,12 @@
-/** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-
 import { evaluate } from "./internal.js";
 
 /**
  * Given parsed Origami code, return a function that executes that code.
  *
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
+ *
  * @param {import("../../index.js").AnnotatedCode} code - parsed Origami expression
- * @param {AsyncTree} parent - the parent tree in which the code is running
+ * @param {SyncOrAsyncMap} parent - the parent tree in which the code is running
  */
 export function createExpressionFunction(code, parent) {
   async function fn() {

package/src/runtime/expressionObject.js

@@ -1,6 +1,6 @@
 import {
   extension,
-  ObjectTree,
+  ObjectMap,
   setParent,
   symbols,
   trailingSlash,
@@ -30,14 +30,15 @@ export default async function expressionObject(entries, state = {}) {
   // Create the object and set its parent
   const object = {};
   const parent = state?.object ?? null;
-  if (parent !== null && !Tree.isAsyncTree(parent)) {
-    throw new TypeError(`Parent must be an AsyncTree or null`);
+  if (parent !== null && !Tree.isMap(parent)) {
+    throw new TypeError(`Parent must be a map or null`);
   }
   setParent(object, parent);
 
   let tree;
   const eagerProperties = [];
   const propertyIsEnumerable = {};
+  let hasLazyProperties = false;
   for (let [key, value] of entries) {
     // Determine if we need to define a getter or a regular property. If the key
     // has an extension, we need to define a getter. If the value is code (an
@@ -80,6 +81,7 @@ export default async function expressionObject(entries, state = {}) {
       // Property getter
       let code;
       if (value[0] === ops.getter) {
+        hasLazyProperties = true;
         code = value[1];
       } else {
         eagerProperties.push(key);
@@ -87,7 +89,7 @@ export default async function expressionObject(entries, state = {}) {
       }
 
       const get = async () => {
-        tree ??= new ObjectTree(object);
+        tree ??= new ObjectMap(object);
         const newState = Object.assign({}, state, { object: tree });
         const result = await evaluate(code, newState);
         return extname ? handleExtension(result, key, tree) : result;
@@ -113,8 +115,7 @@ export default async function expressionObject(entries, state = {}) {
   // and overwrite the property getter with the actual value.
   for (const key of eagerProperties) {
     const value = await object[key];
-    // @ts-ignore Unclear why TS thinks `object` might be undefined here
-    const enumerable = Object.getOwnPropertyDescriptor(object, key).enumerable;
+    const enumerable = Object.getOwnPropertyDescriptor(object, key)?.enumerable;
     Object.defineProperty(object, key, {
       configurable: true,
       enumerable,
@@ -123,6 +124,16 @@ export default async function expressionObject(entries, state = {}) {
     });
   }
 
+  // If there are any getters, mark the object as async
+  if (hasLazyProperties) {
+    Object.defineProperty(object, symbols.async, {
+      configurable: true,
+      enumerable: false,
+      value: true,
+      writable: true,
+    });
+  }
+
   return object;
 }
 
@@ -141,8 +152,8 @@ export function entryKey(entry, object = null, eagerProperties = []) {
     return key;
   }
 
-  // If eager property value is treelike, add slash to the key
-  if (eagerProperties.includes(key) && Tree.isTreelike(object?.[key])) {
+  // If eager property value is maplike, add slash to the key
+  if (eagerProperties.includes(key) && Tree.isMaplike(object?.[key])) {
     return trailingSlash.add(key);
   }
 

package/src/runtime/handleExtension.js

@@ -18,7 +18,7 @@ let projectGlobals;
  *
  * @param {any} value
  * @param {any} key
- * @param {import("@weborigami/types").AsyncTree} [parent]
+ * @param {import("@weborigami/async-tree").SyncOrAsyncMap} [parent]
  */
 export default async function handleExtension(value, key, parent) {
   projectGlobals ??= await globals();
@@ -28,13 +28,9 @@ export default async function handleExtension(value, key, parent) {
       key = trailingSlash.remove(key);
     }
 
-    // Special cases: `.ori.<ext>` extensions are Origami documents,
-    // `.jse.<ext>` are JSE documents.
-    // TODO: Remove .jse.<ext>
+    // Special cases: `.ori.<ext>` extensions are Origami documents
     const extname = key.match(/\.ori\.\S+$/)
       ? ".oridocument"
-      : key.match(/\.jse\.\S+$/)
-      ? ".jsedocument"
       : extension.extname(key);
     if (extname) {
       const handlerName = `${extname.slice(1)}_handler`;

package/src/runtime/mergeTrees.js

@@ -3,14 +3,13 @@ import { isPlainObject, isUnpackable, Tree } from "@weborigami/async-tree";
 /**
  * Create a tree that's the result of merging the given trees.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
  *
- * @param {(Treelike|null)[]} trees
+ * @param {(Maplike|null)[]} trees
  */
 export default async function mergeTrees(...trees) {
   // Filter out null or undefined trees.
-  /** @type {Treelike[]}
+  /** @type {Maplike[]}
    * @ts-ignore */
   const filtered = trees.filter((tree) => tree);
 
@@ -27,9 +26,7 @@ export default async function mergeTrees(...trees) {
   );
 
   // If all trees are plain objects, return a plain object.
-  if (
-    unpacked.every((tree) => isPlainObject(tree) && !Tree.isAsyncTree(tree))
-  ) {
+  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 = {};

package/src/runtime/ops.js

@@ -1,17 +1,17 @@
 /**
  * @typedef {import("../../index.ts").AnnotatedCode} AnnotatedCode
- * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("../../index.ts").RuntimeState} RuntimeState
+ * @typedef {import("@weborigami/async-tree").Maplike} Maplike
+ * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
  */
 
-import { isUnpackable, symbols, Tree } from "@weborigami/async-tree";
+import { getParent, isUnpackable, Tree } from "@weborigami/async-tree";
 import os from "node:os";
 import expressionObject from "./expressionObject.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
-import OrigamiFiles from "./OrigamiFiles.js";
+import OrigamiFileMap from "./OrigamiFileMap.js";
 import { codeSymbol } from "./symbols.js";
 
 function addOpLabel(op, label) {
@@ -176,7 +176,7 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
  * Files tree for the user's home directory.
  */
 export async function homeDirectory(...keys) {
-  const tree = new OrigamiFiles(os.homedir());
+  const tree = new OrigamiFileMap(os.homedir());
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
@@ -196,7 +196,7 @@ export async function inherited(depth, state) {
         `Origami internal error: Can't find context object`
       );
     }
-    current = current.parent ?? current[symbols.parent];
+    current = getParent(current);
   }
   return current;
 }
@@ -406,11 +406,11 @@ export async function params(depth, state = {}) {
 addOpLabel(params, "«ops.params»");
 params.needsState = true;
 
-// export function optionalTraverse(treelike, key) {
-//   if (!treelike) {
+// export function optionalTraverse(maplike, key) {
+//   if (!maplike) {
 //     return undefined;
 //   }
-//   return Tree.traverseOrThrow(treelike, key);
+//   return Tree.traverseOrThrow(maplike, key);
 // }
 // addOpLabel(optionalTraverse, "«ops.optionalTraverse");
 
@@ -436,7 +436,7 @@ export async function property(object, key) {
   if (key in object) {
     // Object defines the property, get it
     let value = object[key];
-    // Is value an instance method? Copied from ObjectTree.
+    // Is value an instance method? Copied from ObjectMap.
     const isInstanceMethod =
       value instanceof Function && !Object.hasOwn(object, key);
     if (isInstanceMethod) {
@@ -460,7 +460,7 @@ addOpLabel(remainder, "«ops.remainder»");
  * Files tree for the filesystem root.
  */
 export async function rootDirectory(...keys) {
-  const tree = new OrigamiFiles("/");
+  const tree = new OrigamiFileMap("/");
   return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");
@@ -468,7 +468,7 @@ addOpLabel(rootDirectory, "«ops.rootDirectory»");
 /**
  * Return the scope of the current tree
  *
- * @param {AsyncTree} parent
+ * @param {SyncOrAsyncMap} parent
  */
 export async function scope(parent) {
   if (!parent) {

package/test/cases/logicalAndExpression.yaml

@@ -108,14 +108,13 @@
   expected: false
   description: "Complex nesting with false at inner-most"
 
-# TODO: Uncomment when we can do math
-# - source: "true && (1 + 1 === 2)"
-#   expected: true
-#   description: "Combines logical AND with equality comparison"
-
-# - source: "false && (5 > 2)"
-#   expected: false
-#   description: "Logical AND with greater-than comparison"
+- source: "true && (1 + 1 === 2)"
+  expected: true
+  description: "Combines logical AND with equality comparison"
+
+- source: "false && (5 > 2)"
+  expected: false
+  description: "Logical AND with greater-than comparison"
 
 - source: "true && (3 || 0)"
   expected: 3

package/test/compiler/compile.test.js

@@ -130,7 +130,7 @@ async function assertCompile(text, expected, options = {}) {
   const parent = options.target ?? null;
   const fn = compile.expression(text, { globals, mode, parent });
   let result = await fn();
-  if (Tree.isTreelike(result)) {
+  if (Tree.isMaplike(result)) {
     result = await Tree.plain(result);
   }
   assert.deepEqual(result, expected);

package/test/compiler/optimize.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree } from "@weborigami/async-tree";
+import { SyncMap } from "@weborigami/async-tree";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
 import {
@@ -313,7 +313,7 @@ describe("optimize", () => {
 });
 
 function assertCompile(expression, expected, mode = "shell") {
-  const parent = new ObjectTree({});
+  const parent = new SyncMap();
   const globals = {};
   const fn = compile.expression(expression, { globals, mode, parent });
   const actual = fn.code;

package/test/generated/logicalAndExpression.test.js

@@ -33,6 +33,8 @@ describe("logicalAndExpression - JavaScript", () => {
   assert.strictEqual((true && true) && true, true, "Nested logical ANDs with all true");
   assert.strictEqual(true && (true && false), false, "Nested logical ANDs with false in inner");
   assert.strictEqual((true && (false && true)), false, "Complex nesting with false at inner-most");
+  assert.strictEqual(true && (1 + 1 === 2), true, "Combines logical AND with equality comparison");
+  assert.strictEqual(false && (5 > 2), false, "Logical AND with greater-than comparison");
   assert.strictEqual(true && (3 || 0), 3, "Logical AND with logical OR");
   assert.strictEqual(true && (0 || 3), 3, "Logical AND with logical OR and falsy values");
   assert.strictEqual('' && false, "", "Falsy string and false");
@@ -70,6 +72,8 @@ describe("logicalAndExpression - Origami", async() => {
   assert.strictEqual(await oriEval("(true && true) && true"), true, "Nested logical ANDs with all true");
   assert.strictEqual(await oriEval("true && (true && false)"), false, "Nested logical ANDs with false in inner");
   assert.strictEqual(await oriEval("(true && (false && true))"), false, "Complex nesting with false at inner-most");
+  assert.strictEqual(await oriEval("true && (1 + 1 === 2)"), true, "Combines logical AND with equality comparison");
+  assert.strictEqual(await oriEval("false && (5 > 2)"), false, "Logical AND with greater-than comparison");
   assert.strictEqual(await oriEval("true && (3 || 0)"), 3, "Logical AND with logical OR");
   assert.strictEqual(await oriEval("true && (0 || 3)"), 3, "Logical AND with logical OR and falsy values");
   assert.strictEqual(await oriEval("'' && false"), "", "Falsy string and false");

package/test/handlers/csv_handler.test.js

@@ -10,17 +10,17 @@ Bob,25,Los Angeles
 "Carol ""CJ""",22,Chicago`;
     const result = csv_handler.unpack(csvText);
     assert.deepStrictEqual(result, [
-      { name: "Alice", age: "30", city: "New York, NY" },
-      { name: "Bob", age: "25", city: "Los Angeles" },
-      { name: 'Carol "CJ"', age: "22", city: "Chicago" },
+      { name: "Alice", age: 30, city: "New York, NY" },
+      { name: "Bob", age: 25, city: "Los Angeles" },
+      { name: 'Carol "CJ"', age: 22, city: "Chicago" },
     ]);
   });
 
   test("handles CRLF line endings", () => {
     const textCRLF = `name,age,city\r\nAlice,30,"New York, NY"\r\nBob,25,Los Angeles\r\n`;
     const expected = [
-      { name: "Alice", age: "30", city: "New York, NY" },
-      { name: "Bob", age: "25", city: "Los Angeles" },
+      { name: "Alice", age: 30, city: "New York, NY" },
+      { name: "Bob", age: 25, city: "Los Angeles" },
     ];
     const result = csv_handler.unpack(textCRLF);
     assert.deepStrictEqual(result, expected);

package/test/handlers/js_handler.test.js

@@ -1,11 +1,11 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import js_handler from "../../src/handlers/js_handler.js";
 import ImportModulesMixin from "../../src/runtime/ImportModulesMixin.js";
 
 const fixturesUrl = new URL("fixtures", import.meta.url);
-const fixturesTree = new (ImportModulesMixin(FileTree))(fixturesUrl);
+const fixturesTree = new (ImportModulesMixin(FileMap))(fixturesUrl);
 
 describe(".js handler", () => {
   test("loads .js file that exports a string", async () => {

package/test/handlers/ori_handler.test.js

@@ -1,11 +1,11 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import ori_handler from "../../src/handlers/ori_handler.js";
-import OrigamiFiles from "../../src/runtime/OrigamiFiles.js";
+import OrigamiFileMap from "../../src/runtime/OrigamiFileMap.js";
 
 const fixturesUrl = new URL("fixtures", import.meta.url);
-const fixtures = new OrigamiFiles(fixturesUrl);
+const fixtures = new OrigamiFileMap(fixturesUrl);
 
 describe(".ori handler", async () => {
   test("loads a string expression", async () => {
@@ -15,7 +15,7 @@ describe(".ori handler", async () => {
   });
 
   test("loads a tree expression", async () => {
-    const parent = new ObjectTree({
+    const parent = new ObjectMap({
       name: "world",
     });
     const source = `{
@@ -43,15 +43,15 @@ describe(".ori handler", async () => {
   });
 
   test("loads an object containing an object shorthand", async () => {
-    const assets = new ObjectTree({});
-    const parent = new ObjectTree({ assets });
+    const assets = new ObjectMap({});
+    const parent = new ObjectMap({ assets });
     const source = `{ assets }`;
     const object = await ori_handler.unpack(source, { parent });
     assert.equal(object.assets, assets);
   });
 
   test("loads a template literal", async () => {
-    const scope = new ObjectTree({
+    const scope = new ObjectMap({
       name: "Alice",
     });
     const source = `\`Hello, \${name}!\``;
@@ -62,7 +62,7 @@ describe(".ori handler", async () => {
   });
 
   test("loads a template lambda that reads from parent scope", async () => {
-    const parent = new ObjectTree({
+    const parent = new ObjectMap({
       name: "Alice",
     });
     const source = `() => \`Hello, \${name}!\``;

package/test/handlers/oridocument_handler.test.js

@@ -1,11 +1,11 @@
-import { ObjectTree } from "@weborigami/async-tree";
+import { ObjectMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import oridocument_handler from "../../src/handlers/oridocument_handler.js";
 
 describe("Origami document handler", () => {
   test("unpacks text with Origami expressions", async () => {
-    const parent = new ObjectTree({
+    const parent = new ObjectMap({
       name: "world",
     });
     const text = "Hello, ${ name }!";
@@ -28,7 +28,7 @@ describe("Origami document handler", () => {
   });
 
   test("YAML front matter is returned with _body", async () => {
-    const parent = new ObjectTree({
+    const parent = new ObjectMap({
       message: "Hello",
     });
     const text = `---

package/test/handlers/tsv_handler.test.js

@@ -10,17 +10,17 @@ Bob\t25\tLos Angeles
 Carol\t22\tChicago`;
     const result = tsv_handler.unpack(TSVText);
     assert.deepStrictEqual(result, [
-      { name: "Alice", age: "30", city: "New York, NY" },
-      { name: "Bob", age: "25", city: "Los Angeles" },
-      { name: "Carol", age: "22", city: "Chicago" },
+      { name: "Alice", age: 30, city: "New York, NY" },
+      { name: "Bob", age: 25, city: "Los Angeles" },
+      { name: "Carol", age: 22, city: "Chicago" },
     ]);
   });
 
   test("handles CRLF line endings", () => {
     const textCRLF = `name\tage\tcity\r\nAlice\t30\tNew York, NY\r\nBob\t25\tLos Angeles\r\n`;
     const expected = [
-      { name: "Alice", age: "30", city: "New York, NY" },
-      { name: "Bob", age: "25", city: "Los Angeles" },
+      { name: "Alice", age: 30, city: "New York, NY" },
+      { name: "Bob", age: 25, city: "Los Angeles" },
     ];
     const result = tsv_handler.unpack(textCRLF);
     assert.deepStrictEqual(result, expected);

package/test/handlers/wasm_handler.test.js

@@ -1,11 +1,11 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import wasm_handler from "../../src/handlers/wasm_handler.js";
 import ImportModulesMixin from "../../src/runtime/ImportModulesMixin.js";
 
 const fixturesUrl = new URL("fixtures", import.meta.url);
-const fixturesTree = new (ImportModulesMixin(FileTree))(fixturesUrl);
+const fixturesTree = new (ImportModulesMixin(FileMap))(fixturesUrl);
 
 describe(".wasm handler", () => {
   test("loads .wasm file that exports a function", async () => {

package/test/runtime/OrigamiFileMap.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
+import path from "node:path";
+import { describe, test } from "node:test";
+import { fileURLToPath } from "node:url";
+import OrigamiFileMap from "../../src/runtime/OrigamiFileMap.js";
+
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const tempDirectory = path.join(dirname, "fixtures/temp/OrigamiFileMap");
+
+describe("OrigamiFileMap", () => {
+  test.skip("can watch its folder for changes", { timeout: 2000 }, async () => {
+    createTempDirectory();
+
+    const tempFiles = new OrigamiFileMap(tempDirectory);
+    const changedFileName = await new Promise(async (resolve) => {
+      tempFiles.addEventListener("change", (event) => {
+        resolve(/** @type {any} */ (event).options.key);
+      });
+      tempFiles.set(
+        "foo.txt",
+        "This file is left over from testing and can be removed."
+      );
+    });
+    removeTempDirectory();
+    assert.equal(changedFileName, "foo.txt");
+  });
+});
+
+function createTempDirectory() {
+  // Remove any existing files or directories inside the temp directory so
+  // tests start from a clean slate. Use force so this is safe if the
+  // directory doesn't exist.
+  fs.rmSync(tempDirectory, { force: true, recursive: true });
+  fs.mkdirSync(tempDirectory, { recursive: true });
+}
+
+function removeTempDirectory() {
+  fs.rmSync(tempDirectory, { force: true, recursive: true });
+}

package/test/runtime/evaluate.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
-import { ObjectTree } from "@weborigami/async-tree";
+import { SyncMap } from "@weborigami/async-tree";
 import evaluate from "../../src/runtime/evaluate.js";
 import { createCode } from "../compiler/codeHelpers.js";
 
@@ -27,12 +27,12 @@ describe("evaluate", () => {
   });
 
   test("if function has containerAsTarget, it gets bound to state.container", async () => {
-    /** @this {import("@weborigami/types").AsyncTree} */
+    /** @this {import("@weborigami/async-tree").SyncOrAsyncMap} */
     const fn = function () {
       return this;
     };
     fn.containerAsTarget = true;
-    const container = new ObjectTree({});
+    const container = new SyncMap();
     const state = { container };
     const code = createCode([fn]);
     const result = await evaluate(code, state);

package/test/runtime/expressionObject.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import { ObjectMap, symbols, SyncMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -7,7 +7,7 @@ import { ops } from "../../src/runtime/internal.js";
 
 describe("expressionObject", () => {
   test("can instantiate an object", async () => {
-    const container = new ObjectTree({
+    const container = new ObjectMap({
       upper: (s) => s.toUpperCase(),
     });
 
@@ -15,7 +15,7 @@ describe("expressionObject", () => {
       ["hello", [[[ops.scope, container], "upper"], "hello"]],
       ["world", [[[ops.scope, container], "upper"], "world"]],
     ];
-    const context = new ObjectTree({});
+    const context = new SyncMap();
 
     const object = await expressionObject(entries, { object: context });
     assert.equal(await object.hello, "HELLO");
@@ -43,7 +43,7 @@ describe("expressionObject", () => {
       ["name", "world"],
       ["message", [ops.concat, "Hello, ", [[ops.inherited, 0], "name"], "!"]],
     ];
-    const context = new ObjectTree({});
+    const context = new SyncMap();
     const object = await expressionObject(entries, { object: context });
     assert.deepEqual(await Tree.plain(object), {
       name: "world",
@@ -54,7 +54,7 @@ describe("expressionObject", () => {
 
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
-    const context = new ObjectTree({});
+    const context = new SyncMap();
     const result = await expressionObject(entries, { object: context });
     const dataJson = await result["data.json"];
     const json = await dataJson.unpack();
@@ -77,7 +77,7 @@ describe("expressionObject", () => {
       ["getter", [ops.getter, [ops.object, ["b", [ops.literal, 2]]]]],
       ["hasSlash/", "This isn't really a tree but says it is"],
       ["message", "Hello"],
-      // Immediate treelike value, should have a slash
+      // Immediate maplike value, should have a slash
       ["object", [ops.object, ["b", [ops.literal, 2]]]],
     ];
     const object = await expressionObject(entries);
@@ -88,4 +88,12 @@ describe("expressionObject", () => {
       "object/",
     ]);
   });
+
+  test("sets symbols.async on objects with getters", async () => {
+    const noGetter = await expressionObject([["eager", 1]]);
+    assert.equal(noGetter[symbols.async], undefined);
+
+    const hasGetter = await expressionObject([["lazy", [ops.getter, [2]]]]);
+    assert.equal(hasGetter[symbols.async], true);
+  });
 });

package/test/runtime/handleExtension.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree } from "@weborigami/async-tree";
+import { ObjectMap } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import handleExtension from "../../src/runtime/handleExtension.js";
@@ -25,7 +25,7 @@ describe("handleExtension", () => {
 });
 
 function createFixture() {
-  return new ObjectTree({
+  return new ObjectMap({
     foo: 1, // No extension, should be left alone
     "bar.json": `{ "bar": 2 }`,
   });

package/test/runtime/mergeTrees.test.js

@@ -1,4 +1,4 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import mergeTrees from "../../src/runtime/mergeTrees.js";
@@ -42,7 +42,7 @@ describe("mergeTrees", () => {
 
   test("merges heterogenous arguments as trees", async () => {
     const tree = await mergeTrees(
-      new ObjectTree({
+      new ObjectMap({
         a: 1,
         b: 2,
       }),

package/test/runtime/ops.test.js

@@ -1,4 +1,4 @@
-import { DeepObjectTree, ObjectTree, Tree } from "@weborigami/async-tree";
+import { DeepObjectMap, ObjectMap, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -128,12 +128,12 @@ describe("ops", () => {
       assert.deepEqual(await ops.flat(1, 2, [3]), [1, 2, 3]);
     });
 
-    test("flattens treelike objects", async () => {
+    test("flattens maplike objects", async () => {
       const object = {
         a: 1,
         b: 2,
       };
-      const tree = new ObjectTree({
+      const tree = new ObjectMap({
         c: 3,
         d: 4,
       });
@@ -156,7 +156,7 @@ describe("ops", () => {
   });
 
   test("ops.inherited walks up the object parent chain", async () => {
-    const tree = new DeepObjectTree({
+    const tree = new DeepObjectMap({
       a: {
         b: {},
       },
@@ -368,7 +368,7 @@ describe("ops", () => {
 
   describe("ops.scope", () => {
     test("returns the scope of the given tree", async () => {
-      const tree = new DeepObjectTree({
+      const tree = new DeepObjectMap({
         a: {
           b: {},
         },

package/src/runtime/InvokeFunctionsTransform.d.ts

@@ -1,5 +0,0 @@
-import { Mixin } from "../../index.ts";
-
-declare const InvokeFunctionsTransform: Mixin<{}>;
-
-export default InvokeFunctionsTransform;

package/src/runtime/InvokeFunctionsTransform.js

@@ -1,25 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-/**
- * When using `get` to retrieve a value from a tree, if the value is a
- * function, invoke it and return the result.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
- * @param {AsyncTreeConstructor} Base
- */
-export default function InvokeFunctionsTransform(Base) {
-  return class InvokeFunctions extends Base {
-    async get(key) {
-      let value = await super.get(key);
-      if (typeof value === "function") {
-        value = await value();
-
-        if (Tree.isAsyncTree(value) && !value.parent) {
-          value.parent = this;
-        }
-      }
-      return value;
-    }
-  };
-}

package/src/runtime/functionResultsMap.js

@@ -1,17 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-/**
- * When using `get` to retrieve a value from a tree, if the value is a
- * function, invoke it and return the result.
- */
-export default async function functionResultsMap(treelike) {
-  return Tree.map(treelike, {
-    description: "functionResultsMap",
-
-    value: async (sourceValue, sourceKey, tree) => {
-      const resultValue =
-        typeof sourceValue === "function" ? await sourceValue() : sourceValue;
-      return resultValue;
-    },
-  });
-}

package/test/runtime/OrigamiFiles.test.js

@@ -1,35 +0,0 @@
-import assert from "node:assert";
-import * as fs from "node:fs/promises";
-import path from "node:path";
-import { describe, test } from "node:test";
-import { fileURLToPath } from "node:url";
-import OrigamiFiles from "../../src/runtime/OrigamiFiles.js";
-
-const dirname = path.dirname(fileURLToPath(import.meta.url));
-const tempDirectory = path.join(dirname, "fixtures/temp");
-
-describe("OrigamiFiles", () => {
-  test("can watch its folder for changes", { timeout: 2000 }, async () => {
-    await createTempDirectory();
-    const tempFiles = new OrigamiFiles(tempDirectory);
-    const changedFileName = await new Promise(async (resolve) => {
-      tempFiles.addEventListener("change", (event) => {
-        resolve(/** @type {any} */ (event).options.key);
-      });
-      await tempFiles.set(
-        "foo.txt",
-        "This file is left over from testing and can be removed."
-      );
-    });
-    await removeTempDirectory();
-    assert.equal(changedFileName, "foo.txt");
-  });
-});
-
-async function createTempDirectory() {
-  await fs.mkdir(tempDirectory, { recursive: true });
-}
-
-async function removeTempDirectory() {
-  await fs.rm(tempDirectory, { recursive: true });
-}

package/test/runtime/fixtures/subgraph = this.js

@@ -1,5 +0,0 @@
-import { ObjectTree } from "@weborigami/async-tree";
-export default new ObjectTree({
-  a: "Hello, a.",
-  b: "Hello, b.",
-});

package/test/runtime/functionResultsMap.test.js

@@ -1,20 +0,0 @@
-import { ObjectTree, Tree } from "@weborigami/async-tree";
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import functionResultsMap from "../../src/runtime/functionResultsMap.js";
-
-describe("functionResultsMap", () => {
-  test("get() invokes functions, returns other values as is", async () => {
-    const tree = new ObjectTree({
-      fn: function () {
-        return "Hello";
-      },
-      string: "string",
-    });
-    const fixture = await functionResultsMap(tree);
-    assert.deepEqual(await Tree.plain(fixture), {
-      fn: "Hello",
-      string: "string",
-    });
-  });
-});