@weborigami/language 0.5.8 → 0.6.1

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/errors.js

@@ -95,7 +95,9 @@ export function formatError(error) {
         error.message === "A null or undefined value can't be traversed"
       ) {
         // Provide more meaningful message for TraverseError
-        line = `TraverseError: This part of the path is null or undefined: ${fragment}`;
+        line = `TraverseError: This part of the path is null or undefined: ${highlightError(
+          fragment
+        )}`;
         fragmentInMessage = true;
       }
       if (message) {
@@ -110,7 +112,7 @@ export function formatError(error) {
   // Add location
   if (location) {
     if (!fragmentInMessage) {
-      message += `\nevaluating: ${fragment}`;
+      message += `\nevaluating: ${highlightError(fragment)}`;
     }
     message += lineInfo(location);
   }
@@ -130,6 +132,11 @@ export async function formatScopeTypos(scope, key) {
   return `Maybe you meant ${list}?`;
 }
 
+export function highlightError(text) {
+  // ANSI escape sequence to highlight text in red
+  return `\x1b[31m${text}\x1b[0m`;
+}
+
 export function maybeOrigamiSourceCode(text) {
   return origamiSourceSignals.some((signal) => text.includes(signal));
 }

package/src/runtime/evaluate.js

@@ -36,7 +36,7 @@ export default async function evaluate(code, state = {}) {
     const error = ReferenceError(
       `${codeFragment(code[0].location)} is not defined`
     );
-    /** @type {any} */ (error).location = code.location;
+    /** @type {any} */ (error).location = code[0].location;
     throw error;
   }
 

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`;
@@ -45,11 +41,6 @@ export default async function handleExtension(value, key, parent) {
           handler = await handler.unpack();
         }
 
-        if (hasSlash && handler.unpack) {
-          // Key like `data.json/` ends in slash -- unpack immediately
-          return handler.unpack(value, { key, parent });
-        }
-
         // If the value is a primitive, box it so we can attach data to it.
         value = box(value);
 

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/compiler/parse.test.js

@@ -233,8 +233,8 @@ describe("Origami parser", () => {
 
     test("with paths", () => {
       assertParse("callExpression", "tree/", [
-        ops.unpack,
-        [markers.traverse, [markers.reference, "tree/"]],
+        markers.traverse,
+        [markers.reference, "tree/"],
       ]);
       assertParse("callExpression", "tree/foo/bar", [
         markers.traverse,
@@ -243,13 +243,10 @@ describe("Origami parser", () => {
         [ops.literal, "bar"],
       ]);
       assertParse("callExpression", "tree/foo/bar/", [
-        ops.unpack,
-        [
-          markers.traverse,
-          [markers.reference, "tree/"],
-          [ops.literal, "foo/"],
-          [ops.literal, "bar/"],
-        ],
+        markers.traverse,
+        [markers.reference, "tree/"],
+        [ops.literal, "foo/"],
+        [ops.literal, "bar/"],
       ]);
       // Consecutive slahes in a path are removed
       assertParse("callExpression", "tree//key", [
@@ -1032,7 +1029,7 @@ Body`,
       ]);
       assertParse("objectEntry", "folder/", [
         "folder/",
-        [ops.unpack, [markers.traverse, [markers.reference, "folder/"]]],
+        [markers.traverse, [markers.reference, "folder/"]],
       ]);
       assertParse("objectEntry", "path/to/file.txt", [
         "file.txt",
@@ -1202,8 +1199,8 @@ Body`,
       [markers.reference, "tree"],
     ]);
     assertParse("pathLiteral", "tree/", [
-      ops.unpack,
-      [markers.traverse, [markers.reference, "tree/"]],
+      markers.traverse,
+      [markers.reference, "tree/"],
     ]);
     assertParse("pathLiteral", "month/12", [
       markers.traverse,
@@ -1211,13 +1208,10 @@ Body`,
       [ops.literal, "12"],
     ]);
     assertParse("pathLiteral", "a/b/c/", [
-      ops.unpack,
-      [
-        markers.traverse,
-        [markers.reference, "a/"],
-        [ops.literal, "b/"],
-        [ops.literal, "c/"],
-      ],
+      markers.traverse,
+      [markers.reference, "a/"],
+      [ops.literal, "b/"],
+      [ops.literal, "c/"],
     ]);
     assertParse("pathLiteral", "~/.cshrc", [
       markers.traverse,

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);