@weborigami/language 0.6.5 → 0.6.7

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";
 
 /**

package/main.js

@@ -4,9 +4,12 @@ export * as compile from "./src/compiler/compile.js";
 export { default as isOrigamiFrontMatter } from "./src/compiler/isOrigamiFrontMatter.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";
 export { default as projectGlobals } from "./src/project/projectGlobals.js";
 export { default as projectRoot } from "./src/project/projectRoot.js";
+export { default as projectRootFromPath } from "./src/project/projectRootFromPath.js";
 export * as Protocols from "./src/protocols/protocols.js";
 export { formatError, highlightError } from "./src/runtime/errors.js";
 export { default as evaluate } from "./src/runtime/evaluate.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "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.5",
+    "@weborigami/async-tree": "0.6.7",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/compiler/optimize.js

@@ -1,6 +1,10 @@
 import { pathFromKeys, trailingSlash } from "@weborigami/async-tree";
 import jsGlobals from "../project/jsGlobals.js";
-import { entryKey } from "../runtime/expressionObject.js";
+import {
+  KEY_TYPE,
+  normalizeKey,
+  propertyInfo,
+} from "../runtime/expressionObject.js";
 import { ops } from "../runtime/internal.js";
 import { annotate, markers, spanLocations } from "./parserHelpers.js";
 
@@ -62,10 +66,7 @@ export default function optimize(code, options = {}) {
 
     case ops.object:
       const entries = args;
-      // Filter out computed property keys when determining local variables
-      const propertyNames = entries
-        .map((entry) => entryKey(entry))
-        .filter((key) => key !== null);
+      const propertyNames = getPropertyNames(entries);
       locals.push({
         type: REFERENCE_INHERITED,
         names: propertyNames,
@@ -207,6 +208,14 @@ function findLocalDetails(key, locals) {
   return null;
 }
 
+function getPropertyNames(entries) {
+  const infos = entries.map(([key, value]) => propertyInfo(key, value));
+  // Filter out computed property keys when determining local variables
+  return infos
+    .filter((info) => info.keyType !== KEY_TYPE.COMPUTED)
+    .map((info) => normalizeKey(info));
+}
+
 function globalReference(key, globals) {
   const normalized = trailingSlash.remove(key);
   return globals[normalized];

package/src/compiler/origami.pegjs

@@ -163,16 +163,18 @@ comment "comment"
   / singleLineComment
 
 computedPropertyAccess
-  = computedPropertySpace "[" expression:expectExpression expectClosingBracket {
+  = computedPropertySpace? "[" expression:expectExpression expectClosingBracket {
       return annotate([markers.property, expression], location());
     }
 
-// A space before a computed property access. This is allowed when not in shell
-// mode. In shell mode `foo [bar]` should parse as a function call with a single
-// argument of an array, not as a property access.
+// An inline space before a computed property access. This is allowed when not
+// in shell mode. In shell mode `foo [bar]` should parse as a function call with
+// a single argument of an array, not as a property access. In program made, we
+// allow an inline space per JavaScript. JavaScript also allows newlines, but we
+// disallow those to avoid confusion with array/list/object entry separators.
 computedPropertySpace
   = shellMode
-  / !shellMode __
+  / !shellMode inlineSpace
 
 conditionalExpression
   = condition:logicalOrExpression tail:(__
@@ -750,7 +752,7 @@ parenthesesArgumentList "list"
 // Function arguments in parentheses
 parenthesesArguments "function arguments in parentheses"
   = inlineSpace* "(" __ list:parenthesesArgumentList? __ expectClosingParenthesis {
-      return annotate(list ?? [undefined], location());
+      return annotate(list ?? [], location());
     }
 
 // A slash-separated path of keys that follows a call target, such as the path

package/src/compiler/parse.js

@@ -931,7 +931,7 @@ function peg$parse(input, options) {
     return annotate(args, location());
   }
   function peg$f98(list) {
-    return annotate(list ?? [undefined], location());
+    return annotate(list ?? [], location());
   }
   function peg$f99(keys) {
     const args = keys ?? [];
@@ -2192,25 +2192,23 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     s1 = peg$parsecomputedPropertySpace();
-    if (s1 !== peg$FAILED) {
-      if (input.charCodeAt(peg$currPos) === 91) {
-        s2 = peg$c6;
-        peg$currPos++;
-      } else {
-        s2 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$e9); }
-      }
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseexpectExpression();
-        if (s3 !== peg$FAILED) {
-          s4 = peg$parseexpectClosingBracket();
-          if (s4 !== peg$FAILED) {
-            peg$savedPos = s0;
-            s0 = peg$f16(s3);
-          } else {
-            peg$currPos = s0;
-            s0 = peg$FAILED;
-          }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    if (input.charCodeAt(peg$currPos) === 91) {
+      s2 = peg$c6;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) { peg$fail(peg$e9); }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$parseexpectExpression();
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parseexpectClosingBracket();
+        if (s4 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f16(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -2244,9 +2242,14 @@ function peg$parse(input, options) {
         s1 = peg$FAILED;
       }
       if (s1 !== peg$FAILED) {
-        s2 = peg$parse__();
-        s1 = [s1, s2];
-        s0 = s1;
+        s2 = peg$parseinlineSpace();
+        if (s2 !== peg$FAILED) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;

package/src/project/projectConfig.js

@@ -1,12 +1,12 @@
 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";
+import projectRootFromPath from "./projectRootFromPath.js";
 
 const mapPathToConfig = new Map();
 
 export default async function config(dir = process.cwd()) {
-  const root = await projectRoot(dir);
+  const root = await projectRootFromPath(dir);
 
   const rootPath = root.path;
   const cached = mapPathToConfig.get(rootPath);

package/src/project/projectGlobals.js

@@ -4,14 +4,14 @@ import projectConfig from "./projectConfig.js";
 let globals;
 
 // Core globals plus project config
-export default async function projectGlobals() {
+export default async function projectGlobals(dir = process.cwd()) {
   if (!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();
+    const config = await projectConfig(dir);
     Object.assign(globals, config);
   }
 

package/src/project/projectRoot.js

@@ -1,58 +1,9 @@
-import { FileMap } from "@weborigami/async-tree";
-import path from "node:path";
-import OrigamiFileMap from "../runtime/OrigamiFileMap.js";
-
-const configFileName = "config.ori";
-const packageFileName = "package.json";
-
-const mapPathToRoot = new Map();
+import { Tree } from "@weborigami/async-tree";
 
 /**
- * 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
- * containing folder is considered to be the project root.
- *
- * 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.
- *
- *
- * @param {string} [dirname]
+ * Return an OrigamiFileMap object for the current code context.
  */
-export default async function projectRoot(dirname = process.cwd()) {
-  const cached = mapPathToRoot.get(dirname);
-  if (cached) {
-    return cached;
-  }
-
-  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 {
-    // Try looking for package.json
-    value = await currentTree.get(packageFileName);
-    if (value) {
-      // Found package.json
-      root = new OrigamiFileMap(currentTree.path);
-    } else {
-      // Move up a folder and try again
-      const parentPath = path.dirname(dirname);
-      if (parentPath !== dirname) {
-        root = await projectRoot(parentPath);
-      } else {
-        // At filesystem root, use current working directory
-        root = new OrigamiFileMap(process.cwd());
-      }
-    }
-  }
-
-  mapPathToRoot.set(dirname, root);
-  return root;
+export default async function projectRoot(state) {
+  return Tree.root(state.container);
 }
+projectRoot.needsState = true;

package/src/project/projectRootFromPath.js

@@ -0,0 +1,68 @@
+import { FileMap } from "@weborigami/async-tree";
+import path from "node:path";
+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.
+ *
+ * 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.
+ *
+ *
+ * @param {string} [dirname]
+ */
+export default async function projectRootFromPath(dirname = process.cwd()) {
+  const cached = mapPathToRoot.get(dirname);
+  if (cached) {
+    return cached;
+  }
+
+  let root;
+  let value;
+  // Use a plain FileMap to avoid loading extension handlers
+  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 currentFolder.get(packageFileName);
+    if (value) {
+      // Found package.json
+      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 {
+      // At filesystem root; not found
+      root = null;
+      break;
+    }
+  }
+
+  if (!root) {
+    // Default to using the provided folder as the project root
+    root = new OrigamiFileMap(dirname);
+  }
+
+  mapPathToRoot.set(dirname, root);
+  return root;
+}

package/src/protocols/fetchAndHandleExtension.js

@@ -13,6 +13,11 @@ export default async function fetchAndHandleExtension(href) {
   }
   let buffer = await response.arrayBuffer();
 
+  const mediaType = response.headers.get("Content-Type");
+  if (mediaType) {
+    /** @type {any} */ (buffer).mediaType = mediaType;
+  }
+
   // Attach any loader defined for the file type.
   const url = new URL(href);
   const filename = url.pathname.split("/").pop();

package/src/protocols/files.js

@@ -1,25 +1,28 @@
 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();
+    const { container } = state;
+    basePath = container.path;
   }
   const resolved = path.resolve(basePath, relativePath);
 
   const result = new OrigamiFileMap(resolved);
   return result;
 }
+files.needsState = true;

package/src/protocols/package.js

@@ -2,66 +2,53 @@ import { Tree, keysFromPath } from "@weborigami/async-tree";
 import projectRoot from "../project/projectRoot.js";
 
 /**
- * @param {string[]} keys
+ * The package: protocol handler
+ *
+ * @param {any[]} args
  */
-export default async function packageNamespace(...keys) {
-  const parent = await projectRoot();
-
-  let name = keys.shift();
-  let organization;
-  if (name?.startsWith("@")) {
-    // First key is an npm organization
-    organization = name;
-    if (keys.length === 0) {
-      // Return a function that will process the next key
-      return async (name, ...keys) =>
-        getPackage(parent, organization, name, keys);
-    }
-    name = keys.shift();
-  }
-
-  return getPackage(parent, organization, name, keys);
-}
-
-async function getPackage(parent, organization, name, keys) {
-  const packagePath = ["node_modules"];
-  if (organization) {
-    packagePath.push(organization);
+export default async function packageProtocol(...args) {
+  const state = args.pop(); // Remaining args are the path
+  const root = await projectRoot(state);
+
+  // Identify the path to the package root
+  const packageRootPath = ["node_modules"];
+  const name = args.shift();
+  packageRootPath.push(name);
+  if (name.startsWith("@")) {
+    // First key is an npm organization, add next key as name
+    packageRootPath.push(args.shift());
   }
-  packagePath.push(name);
-
-  const parentScope = await Tree.scope(parent);
-  const packageRoot = await Tree.traverse(
-    // @ts-ignore
-    parentScope,
-    ...packagePath
-  );
 
+  // Get the package root (top level folder of the package)
+  const packageRoot = await Tree.traverse(root, ...packageRootPath);
   if (!packageRoot) {
-    throw new Error(`Can't find ${packagePath.join("/")}`);
+    throw new Error(`Can't find ${packageRootPath.join("/")}`);
   }
 
+  // Identify the main entry point
   const mainPath = await Tree.traverse(packageRoot, "package.json", "main");
   if (!mainPath) {
     throw new Error(
-      `node_modules/${keys.join(
+      `${packageRootPath.join(
         "/"
       )} doesn't contain a package.json with a "main" entry.`
     );
   }
 
+  // Identify the folder containing the main entry point
   const mainKeys = keysFromPath(mainPath);
-  const mainContainerKeys = mainKeys.slice(0, -1);
-  const mainFileName = mainKeys[mainKeys.length - 1];
-  const mainContainer = await Tree.traverse(packageRoot, ...mainContainerKeys);
+  const mainFileName = mainKeys.pop();
+  const mainContainer = await Tree.traverse(packageRoot, ...mainKeys);
   const packageExports = await mainContainer.import(mainFileName);
 
   let result =
     "default" in packageExports ? packageExports.default : packageExports;
 
-  if (keys.length > 0) {
-    result = await Tree.traverse(result, ...keys);
+  // If there are remaining args, traverse into the package exports
+  if (args.length > 0) {
+    result = await Tree.traverse(result, ...args);
   }
 
   return result;
 }
+packageProtocol.needsState = true;

package/src/runtime/expressionObject.js

@@ -9,20 +9,22 @@ import {
 import handleExtension from "./handleExtension.js";
 import { evaluate, ops } from "./internal.js";
 
+export const KEY_TYPE = {
+  STRING: 0, // Simple string key: `a: 1`
+  COMPUTED: 1, // Computed key: `[code]: 1`
+};
+
+const VALUE_TYPE = {
+  PRIMITIVE: 0, // Primitive value: `a: 1`
+  EAGER: 1, // Calculated immediately: `a: 1 + 1`
+  GETTER: 2, // Calculated on demand: `a = fn()`
+};
+
 /**
  * Given an array of entries with string keys and Origami code values (arrays of
  * ops and operands), return an object with the same keys defining properties
  * whose getters evaluate the code.
- *
- * The value can take three forms:
- *
- * 1. A primitive value (string, etc.). This will be defined directly as an
- *    object property.
- * 1. An eager (as opposed to lazy) code entry. This will be evaluated during
- *    this call and its result defined as an object property.
- * 1. A code entry that starts with ops.getter. This will be defined as a
- *    property getter on the object.
- *
+
  * @param {*} entries
  * @param {import("../../index.ts").RuntimeState} [state]
  */
@@ -35,191 +37,204 @@ export default async function expressionObject(entries, state = {}) {
   }
   setParent(object, parent);
 
-  // Get the keys, which might included computed keys
-  const computedKeys = await Promise.all(
-    entries.map(async ([key]) =>
-      key instanceof Array ? await evaluate(key, state) : key
-    )
-  );
-
-  let tree;
-  const eagerProperties = [];
-  const propertyIsEnumerable = {};
-  let hasLazyProperties = false;
-  for (let i = 0; i < entries.length; i++) {
-    let key = computedKeys[i];
-    let value = entries[i][1];
-
-    // 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
-    // array), we need to define a getter -- but if that code takes the form
-    // [ops.getter, <primitive>] or [ops.literal, <value>], we can define a
-    // regular property.
-    let defineProperty;
-    const extname = extension.extname(key);
-    if (extname) {
-      defineProperty = false;
-    } else if (!(value instanceof Array)) {
-      defineProperty = true;
-    } else if (value[0] === ops.getter && !(value[1] instanceof Array)) {
-      defineProperty = true;
-      value = value[1];
-    } else if (value[0] === ops.literal) {
-      defineProperty = true;
-      value = value[1];
-    } else {
-      defineProperty = false;
+  // The object in Map form for use on the stack
+  const map = new ObjectMap(object);
+
+  // Preparation: gather information about all properties
+  const infos = entries.map(([key, value]) => propertyInfo(key, value));
+
+  // First pass: define all properties with plain string keys
+  for (const info of infos) {
+    if (info.keyType === KEY_TYPE.STRING) {
+      defineProperty(object, info, state, map);
     }
+  }
 
-    // If the key is wrapped in parentheses, it is not enumerable.
-    let enumerable = true;
-    if (key[0] === "(" && key[key.length - 1] === ")") {
-      key = key.slice(1, -1);
-      enumerable = false;
+  // Second pass: redefine eager string-keyed properties with actual values.
+  for (const info of infos) {
+    if (
+      info.keyType === KEY_TYPE.STRING &&
+      info.valueType === VALUE_TYPE.EAGER
+    ) {
+      await redefineProperty(object, info);
     }
-    propertyIsEnumerable[key] = enumerable;
-
-    if (defineProperty) {
-      // Define simple property
-      Object.defineProperty(object, key, {
-        configurable: true,
-        enumerable,
-        value,
-        writable: true,
-      });
-    } else {
-      // Property getter
-      let code;
-      if (value[0] === ops.getter) {
-        hasLazyProperties = true;
-        code = value[1];
-      } else {
-        eagerProperties.push(key);
-        code = value;
-      }
-
-      const get = async () => {
-        tree ??= new ObjectMap(object);
-        const newState = Object.assign({}, state, { object: tree });
-        const result = await evaluate(code, newState);
-        return extname ? handleExtension(result, key, tree) : result;
-      };
-
-      Object.defineProperty(object, key, {
-        configurable: true,
-        enumerable,
-        get,
-      });
+  }
+
+  // Third pass: define all computed properties. These may refer to the
+  // properties we just defined.
+  for (const info of infos) {
+    if (info.keyType === KEY_TYPE.COMPUTED) {
+      const newState = Object.assign({}, state, { object: map });
+      const key = await evaluate(/** @type {any} */ (info.key), newState);
+      // Destructively update the property info with the computed key
+      info.key = key;
+      defineProperty(object, info, state, map);
+    }
+  }
+
+  // Fourth pass: redefine eager computed-keyed properties with actual values.
+  for (const info of infos) {
+    if (
+      info.keyType === KEY_TYPE.COMPUTED &&
+      info.valueType === VALUE_TYPE.EAGER
+    ) {
+      await redefineProperty(object, info);
     }
   }
 
-  // Attach a keys method
+  // Attach a keys method, where keys for primitive/eager properties with
+  // maplike values get a trailing slash.
   Object.defineProperty(object, symbols.keys, {
     configurable: true,
     enumerable: false,
     value: () =>
-      objectKeys(
-        object,
-        computedKeys,
-        eagerProperties,
-        propertyIsEnumerable,
-        entries
-      ),
+      infos
+        .filter((info) => info.enumerable)
+        .map((info) => normalizeKey(info, object)),
     writable: true,
   });
 
-  // Evaluate any properties that were declared as immediate: get their value
-  // and overwrite the property getter with the actual value.
-  for (const key of eagerProperties) {
-    const value = await object[key];
-    const enumerable = Object.getOwnPropertyDescriptor(object, key)?.enumerable;
+  // TODO: If there are any getters, mark the object as async. Note: this code
+  // was added so that Tree.from() could know whether to return an ObjectMap or
+  // a hypothetical AsyncObjectMap, which in turn would let a map operation know
+  // whether to expect async property values. const hasGetters =
+  // infos.some((info) => info.valueType === VALUE_TYPE.GETTER); if (hasGetters)
+  // { Object.defineProperty(object, symbols.async, { configurable: true,
+  // enumerable: false, value: true, writable: true,
+  //   });
+  // }
+
+  return object;
+}
+
+/**
+ * Define a single property on the object
+ */
+function defineProperty(object, propertyInfo, state, map) {
+  let { enumerable, hasExtension, key, value, valueType } = propertyInfo;
+  if (valueType == VALUE_TYPE.PRIMITIVE) {
+    // Define simple property
     Object.defineProperty(object, key, {
       configurable: true,
       enumerable,
       value,
       writable: true,
     });
-  }
-
-  // If there are any getters, mark the object as async
-  if (hasLazyProperties) {
-    Object.defineProperty(object, symbols.async, {
+  } else {
+    // Eager or getter; will evaluate eager property later
+    Object.defineProperty(object, key, {
       configurable: true,
-      enumerable: false,
-      value: true,
-      writable: true,
+      enumerable,
+      get: async () => {
+        const newState = Object.assign({}, state, { object: map });
+        const result = await evaluate(value, newState);
+        return hasExtension ? handleExtension(result, key, map) : result;
+      },
     });
   }
-
-  return object;
 }
 
-export function entryKey(entry, object = null, eagerProperties = []) {
-  let [key, value] = entry;
-
-  if (typeof key !== "string") {
-    // Computed property key
-    return null;
-  }
-
-  if (key[0] === "(" && key[key.length - 1] === ")") {
-    // Non-enumerable property, remove parentheses. This doesn't come up in the
-    // constructor, but can happen in situations encountered by the compiler's
-    // optimizer.
-    key = key.slice(1, -1);
-  }
+/**
+ * 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;
 
   if (trailingSlash.has(key)) {
     // Explicit trailing slash, return as is
     return key;
   }
 
-  // If eager property value is maplike, add slash to the key
-  if (eagerProperties.includes(key) && Tree.isMaplike(object?.[key])) {
+  // If actual property value is maplike, add slash
+  if (
+    (valueType === VALUE_TYPE.EAGER || valueType === VALUE_TYPE.PRIMITIVE) &&
+    Tree.isMaplike(object?.[key])
+  ) {
     return trailingSlash.add(key);
   }
 
+  // Look at value code to see if it will produce a maplike value
   if (!(value instanceof Array)) {
     // Can't be a subtree
     return trailingSlash.remove(key);
   }
-
-  // If we're dealing with a getter, work with what that gets
-  if (value[0] === ops.getter) {
-    value = value[1];
-  }
-
-  // If entry will definitely create a subtree, add a trailing slash
   if (value[0] === ops.object) {
-    // Subtree
+    // Creates an object; maplike
     return trailingSlash.add(key);
   }
-
-  // See if it looks a merged object
   if (value[1] === "_result" && value[0][0] === ops.object) {
-    // Merge
+    // Merges an object; maplike
     return trailingSlash.add(key);
   }
 
+  // Return as is
   return key;
 }
 
-function objectKeys(
-  object,
-  computedKeys,
-  eagerProperties,
-  propertyIsEnumerable,
-  entries
-) {
-  // If the key is a simple string key and it's enumerable, get the friendly
-  // version of it; if it's a computed key used that.
-  const keys = entries.map((entry, index) =>
-    typeof entry[0] !== "string"
-      ? computedKeys[index]
-      : propertyIsEnumerable[entry[0]]
-      ? entryKey(entry, object, eagerProperties)
-      : null
-  );
-  // Return the enumerable keys
-  return keys.filter((key) => key !== null);
+/**
+ * Given a key and the code for its value, determine some basic aspects of the
+ * property. This may return an updated key and/or value as well.
+ */
+export function propertyInfo(key, value) {
+  // If the key is wrapped in parentheses, it is not enumerable.
+  let enumerable = true;
+  if (
+    typeof key === "string" &&
+    key[0] === "(" &&
+    key[key.length - 1] === ")"
+  ) {
+    key = key.slice(1, -1);
+    enumerable = false;
+  }
+
+  const keyType = key instanceof Array ? KEY_TYPE.COMPUTED : KEY_TYPE.STRING;
+
+  let valueType;
+  if (!(value instanceof Array)) {
+    // Primitive, no code to evaluate
+    valueType = VALUE_TYPE.PRIMITIVE;
+  } else if (value[0] !== ops.getter) {
+    // Code will be eagerly evaluated when object is constructed
+    valueType = VALUE_TYPE.EAGER;
+  } else {
+    // Defined as a getter
+    value = value[1]; // The actual code
+    if (!(value instanceof Array)) {
+      // Getter returns a primitive value; treat as regular property
+      valueType = VALUE_TYPE.PRIMITIVE;
+    } else if (value[0] === ops.literal) {
+      // Getter returns a literal value; treat as eager property
+      valueType = VALUE_TYPE.EAGER;
+    } else {
+      valueType = VALUE_TYPE.GETTER;
+    }
+  }
+
+  // Special case: a key with an extension has to be a getter
+  const hasExtension =
+    typeof key === "string" && extension.extname(key).length > 0;
+  if (hasExtension) {
+    valueType = VALUE_TYPE.GETTER;
+  }
+
+  return { enumerable, hasExtension, key, keyType, value, valueType };
+}
+
+/**
+ * Get the value of the indicated eager property and overwrite the property
+ * definition with the actual value.
+ */
+async function redefineProperty(object, info) {
+  const value = await object[info.key];
+  Object.defineProperty(object, info.key, {
+    configurable: true,
+    enumerable: info.enumerable,
+    value,
+    writable: true,
+  });
 }

package/src/runtime/handleExtension.js

@@ -21,7 +21,6 @@ let projectGlobals;
  * @param {import("@weborigami/async-tree").SyncOrAsyncMap} [parent]
  */
 export default async function handleExtension(value, key, parent) {
-  projectGlobals ??= await globals();
   if (isPacked(value) && isStringlike(key) && value.unpack === undefined) {
     const hasSlash = trailingSlash.has(key);
     if (hasSlash) {
@@ -34,7 +33,8 @@ export default async function handleExtension(value, key, parent) {
       : extension.extname(key);
     if (extname) {
       const handlerName = `${extname.slice(1)}_handler`;
-      let handler = await projectGlobals[handlerName];
+      const handlers = await getHandlers(parent);
+      let handler = await handlers[handlerName];
       if (handler) {
         if (isUnpackable(handler)) {
           // The extension handler itself needs to be unpacked
@@ -66,3 +66,19 @@ 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/test/compiler/parse.test.js

@@ -172,7 +172,7 @@ describe("Origami parser", () => {
                 ops.lambda,
                 0,
                 [],
-                [[markers.traverse, [markers.reference, "fn"]], undefined],
+                [[markers.traverse, [markers.reference, "fn"]]],
               ],
             ],
           ],
@@ -371,7 +371,7 @@ describe("Origami parser", () => {
   describe("callExpression", () => {
     test("call chains", () => {
       assertParse("callExpression", "(foo.js())('arg')", [
-        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
+        [[markers.traverse, [markers.reference, "foo.js"]]],
         [ops.literal, "arg"],
       ]);
       assertParse("callExpression", "fn('a')('b')", [
@@ -382,7 +382,7 @@ describe("Origami parser", () => {
         [ops.literal, "b"],
       ]);
       assertParse("callExpression", "(foo.js())(a, b)", [
-        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
+        [[markers.traverse, [markers.reference, "foo.js"]]],
         [markers.traverse, [markers.reference, "a"]],
         [markers.traverse, [markers.reference, "b"]],
       ]);
@@ -546,7 +546,6 @@ describe("Origami parser", () => {
     test("parentheses arguments", () => {
       assertParse("callExpression", "fn()", [
         [markers.traverse, [markers.reference, "fn"]],
-        undefined,
       ]);
       assertParse("callExpression", "foo.js(arg)", [
         [markers.traverse, [markers.reference, "foo.js"]],
@@ -563,7 +562,7 @@ describe("Origami parser", () => {
         [markers.traverse, [markers.reference, "b"]],
       ]);
       assertParse("callExpression", "fn()(arg)", [
-        [[markers.traverse, [markers.reference, "fn"]], undefined],
+        [[markers.traverse, [markers.reference, "fn"]]],
         [markers.traverse, [markers.reference, "arg"]],
       ]);
     });
@@ -617,19 +616,14 @@ describe("Origami parser", () => {
 
     test("path and parentheses chains", () => {
       assertParse("callExpression", "foo.js()/key", [
-        [[markers.traverse, [markers.reference, "foo.js"]], undefined],
+        [[markers.traverse, [markers.reference, "foo.js"]]],
         [ops.literal, "key"],
       ]);
       assertParse("callExpression", "tree/key()", [
         [markers.traverse, [markers.reference, "tree/"], [ops.literal, "key"]],
-        undefined,
       ]);
       assertParse("callExpression", "fn()/key()", [
-        [
-          [[markers.traverse, [markers.reference, "fn"]], undefined],
-          [ops.literal, "key"],
-        ],
-        undefined,
+        [[[markers.traverse, [markers.reference, "fn"]]], [ops.literal, "key"]],
       ]);
       assertParse("callExpression", "package:@weborigami/dropbox/auth(creds)", [
         [
@@ -1035,7 +1029,7 @@ Body`,
         ops.lambda,
         1,
         [["name", [[ops.params, 0], 0]]],
-        [[markers.traverse, [markers.reference, "_template"]], undefined],
+        [[markers.traverse, [markers.reference, "_template"]]],
       ],
       "program",
       false
@@ -1053,7 +1047,6 @@ Body`,
     ]);
     assertParse("group", "(fn())", [
       [markers.traverse, [markers.reference, "fn"]],
-      undefined,
     ]);
     assertParse("group", "(a -> b)", [
       [markers.traverse, [markers.reference, "b"]],
@@ -1105,7 +1098,7 @@ Body`,
       [markers.traverse, [markers.reference, "c"]],
     ]);
     assertParse("implicitParenthesesCallExpression", "(fn()) 'arg'", [
-      [[markers.traverse, [markers.reference, "fn"]], undefined],
+      [[markers.traverse, [markers.reference, "fn"]]],
       [ops.literal, "arg"],
     ]);
     assertParse(
@@ -1311,10 +1304,7 @@ Body`,
             ops.object,
             [
               "b",
-              [
-                ops.getter,
-                [[markers.traverse, [markers.reference, "fn"]], undefined],
-              ],
+              [ops.getter, [[markers.traverse, [markers.reference, "fn"]]]],
             ],
           ],
         ],
@@ -1506,7 +1496,7 @@ Body`,
   });
 
   test("parenthesesArguments", () => {
-    assertParse("parenthesesArguments", "()", [undefined]);
+    assertParse("parenthesesArguments", "()", []);
     assertParse("parenthesesArguments", "(a, b, c)", [
       [markers.traverse, [markers.reference, "a"]],
       [markers.traverse, [markers.reference, "b"]],

package/test/project/{projectRoot.test.js → projectRootFromPath.test.js}

@@ -2,9 +2,9 @@ import assert from "node:assert";
 import path from "node:path";
 import { describe, test } from "node:test";
 import { fileURLToPath } from "node:url";
-import projectRoot from "../../src/project/projectRoot.js";
+import projectRootFromPath from "../../src/project/projectRootFromPath.js";
 
-describe("projectRoot", () => {
+describe("projectRootFromPath", () => {
   test("finds Origami configuration file", async () => {
     // Find the folder that represents the project root.
     const projectUrl = new URL("fixtures/withConfig/", import.meta.url);
@@ -12,7 +12,7 @@ describe("projectRoot", () => {
     const subfolderUrl = new URL("./subfolder/", projectUrl);
     const subfolderPath = fileURLToPath(subfolderUrl);
 
-    const root = await projectRoot(subfolderPath);
+    const root = await projectRootFromPath(subfolderPath);
 
     // Get result path, it'll need a trailing slash to compare.
     const resultPath = root.path + path.sep;
@@ -26,15 +26,15 @@ describe("projectRoot", () => {
     const subfolderUrl = new URL("./subfolder/", projectUrl);
     const subfolderPath = fileURLToPath(subfolderUrl);
 
-    const root = await projectRoot(subfolderPath);
+    const root = await projectRootFromPath(subfolderPath);
 
     // Get result path, it'll need a trailing slash to compare.
     const resultPath = root.path + path.sep;
     assert.equal(resultPath, fileURLToPath(projectUrl));
   });
 
-  test("defaults to current working directory", async () => {
-    const root = await projectRoot("/");
-    assert.equal(root.path, process.cwd());
+  test("defaults to supplied directory", async () => {
+    const root = await projectRootFromPath("/");
+    assert.equal(root.path, "/");
   });
 });

package/test/protocols/package.test.js

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

package/test/runtime/expressionObject.test.js

@@ -53,11 +53,26 @@ describe("expressionObject", () => {
   });
 
   test("can compute a property key", async () => {
-    const entries = [[[ops.concat, "data", ".json"], 1]];
+    const entries = [
+      [
+        [
+          ops.concat,
+          [
+            [ops.inherited, 0],
+            [ops.literal, "name"], // references `name` on same object
+          ],
+          ".json",
+        ],
+        1,
+      ],
+      ["name", "data"],
+    ];
     const context = new SyncMap();
     const object = await expressionObject(entries, { object: context });
-    assert.equal(await object["data.json"], 1);
-    assert.deepEqual(object[symbols.keys](), ["data.json"]);
+    assert.deepEqual(await Tree.plain(object), {
+      "data.json": 1,
+      name: "data",
+    });
   });
 
   test("returned object values can be unpacked", async () => {
@@ -79,7 +94,7 @@ describe("expressionObject", () => {
     assert.equal(object["hidden"], "shh");
   });
 
-  test("provides a symbols.keys method", async () => {
+  test("provides a symbols.keys method returning normalized keys", async () => {
     const entries = [
       // Will return a tree, should have a slash
       ["getter", [ops.getter, [ops.object, ["b", [ops.literal, 2]]]]],
@@ -100,11 +115,11 @@ describe("expressionObject", () => {
     ]);
   });
 
-  test("sets symbols.async on objects with getters", async () => {
-    const noGetter = await expressionObject([["eager", 1]]);
-    assert.equal(noGetter[symbols.async], undefined);
+  // 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);
-  });
+  //   const hasGetter = await expressionObject([["lazy", [ops.getter, [2]]]]);
+  //   assert.equal(hasGetter[symbols.async], true);
+  // });
 });