@weborigami/language 0.3.3-jse.3 → 0.3.3

package/test/compiler/parse.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { parse } from "../../src/compiler/parse.js";
-import { markers } from "../../src/compiler/parserHelpers.js";
+import { undetermined } from "../../src/compiler/parserHelpers.js";
 import * as ops from "../../src/runtime/ops.js";
 import { assertCodeEqual } from "./codeHelpers.js";
 
@@ -19,63 +19,6 @@ describe("Origami parser", () => {
     ]);
   });
 
-  describe("angleBracketLiteral", () => {
-    test("with path", () => {
-      assertParse(
-        "angleBracketLiteral",
-        "<index.html>",
-        [[ops.scope], [ops.literal, "index.html"]],
-        "jse"
-      );
-      assertParse(
-        "angleBracketLiteral",
-        "<foo/bar/baz>",
-        [
-          [ops.scope],
-          [ops.literal, "foo/"],
-          [ops.literal, "bar/"],
-          [ops.literal, "baz"],
-        ],
-        "jse"
-      );
-    });
-
-    test("root directory", () => {
-      assertParse("angleBracketLiteral", "</>", [ops.rootDirectory]);
-      assertParse("angleBracketLiteral", "</etc/passwd>", [
-        [ops.rootDirectory],
-        [ops.literal, "etc/"],
-        [ops.literal, "passwd"],
-      ]);
-    });
-
-    test("home directory", () => {
-      assertParse("angleBracketLiteral", "<~>", [ops.homeDirectory]);
-      assertParse("angleBracketLiteral", "<~/.bash_profile>", [
-        [ops.homeDirectory],
-        [ops.literal, ".bash_profile"],
-      ]);
-    });
-
-    test("with protocol URL", () => {
-      assertParse("angleBracketLiteral", "<files:src/assets>", [
-        [markers.global, "files:"],
-        [ops.literal, "src/"],
-        [ops.literal, "assets"],
-      ]);
-      assertParse(
-        "angleBracketLiteral",
-        "<https://example.com/data.yaml>",
-        [
-          [markers.global, "https:"],
-          [ops.literal, "example.com/"],
-          [ops.literal, "data.yaml"],
-        ],
-        "jse"
-      );
-    });
-  });
-
   test("arrayLiteral", () => {
     assertParse("arrayLiteral", "[]", [ops.array]);
     assertParse("arrayLiteral", "[1, 2, 3]", [
@@ -98,7 +41,7 @@ describe("Origami parser", () => {
       [ops.literal, 4],
     ]);
     assertParse("arrayLiteral", "[ 1, ...[2, 3]]", [
-      ops.flat,
+      ops.merge,
       [ops.array, [ops.literal, 1]],
       [ops.array, [ops.literal, 2], [ops.literal, 3]],
     ]);
@@ -117,12 +60,12 @@ describe("Origami parser", () => {
     assertParse("arrowFunction", "() => foo", [
       ops.lambda,
       [],
-      [markers.reference, [ops.literal, "foo"]],
+      [ops.scope, "foo"],
     ]);
     assertParse("arrowFunction", "x => y", [
       ops.lambda,
       [[ops.literal, "x"]],
-      [markers.reference, [ops.literal, "y"]],
+      [ops.scope, "y"],
     ]);
     assertParse("arrowFunction", "(a, b, c) ⇒ fn(a, b, c)", [
       ops.lambda,
@@ -132,10 +75,10 @@ describe("Origami parser", () => {
         [ops.literal, "c"],
       ],
       [
-        [markers.global, "fn"],
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
-        [markers.reference, [ops.literal, "c"]],
+        [ops.builtin, "fn"],
+        [ops.scope, "a"],
+        [ops.scope, "b"],
+        [ops.scope, "c"],
       ],
     ]);
     assertParse("arrowFunction", "a => b => fn(a, b)", [
@@ -145,9 +88,9 @@ describe("Origami parser", () => {
         ops.lambda,
         [[ops.literal, "b"]],
         [
-          [markers.global, "fn"],
-          [markers.reference, [ops.literal, "a"]],
-          [markers.reference, [ops.literal, "b"]],
+          [ops.builtin, "fn"],
+          [ops.scope, "a"],
+          [ops.scope, "b"],
         ],
       ],
     ]);
@@ -177,177 +120,147 @@ describe("Origami parser", () => {
     ]);
   });
 
-  describe("callExpression", () => {
-    test("with parentheses arguments", () => {
-      assertParse("callExpression", "fn()", [
-        [markers.global, "fn"],
-        undefined,
-      ]);
-      assertParse("callExpression", "foo.js(arg)", [
-        [markers.reference, [ops.literal, "foo.js"]],
-        [markers.reference, [ops.literal, "arg"]],
-      ]);
-      assertParse("callExpression", "fn(a, b)", [
-        [markers.global, "fn"],
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
-      ]);
-      assertParse("callExpression", "foo.js( a , b )", [
-        [markers.reference, [ops.literal, "foo.js"]],
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
-      ]);
-      assertParse("callExpression", "fn()(arg)", [
-        [[markers.global, "fn"], undefined],
-        [markers.reference, [ops.literal, "arg"]],
-      ]);
-    });
-    test("call chains", () => {
-      assertParse("callExpression", "(foo.js())('arg')", [
-        [[markers.reference, [ops.literal, "foo.js"]], undefined],
-        [ops.literal, "arg"],
-      ]);
-      assertParse("callExpression", "fn('a')('b')", [
-        [
-          [markers.global, "fn"],
-          [ops.literal, "a"],
-        ],
-        [ops.literal, "b"],
-      ]);
-      assertParse("callExpression", "(foo.js())(a, b)", [
-        [[markers.reference, [ops.literal, "foo.js"]], undefined],
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
-      ]);
-    });
-    test("with paths", () => {
-      assertParse("callExpression", "/", [ops.rootDirectory]);
-      assertParse("callExpression", "tree/", [
-        ops.unpack,
-        [markers.reference, [ops.literal, "tree/"]],
-      ]);
-      assertParse("callExpression", "tree/foo/bar", [
-        markers.reference,
-        [ops.literal, "tree/"],
-        [ops.literal, "foo/"],
-        [ops.literal, "bar"],
-      ]);
-      assertParse("callExpression", "tree/foo/bar/", [
-        markers.reference,
-        [ops.literal, "tree/"],
-        [ops.literal, "foo/"],
-        [ops.literal, "bar/"],
-      ]);
-      // Consecutive slahes in a path are removed
-      assertParse("callExpression", "path//key", [
-        markers.reference,
-        [ops.literal, "path/"],
-        [ops.literal, "key"],
-      ]);
-      assertParse("callExpression", "/foo/bar", [
-        [ops.rootDirectory],
-        [ops.literal, "foo/"],
-        [ops.literal, "bar"],
-      ]);
-      assertParse("callExpression", "{ a: 1, b: 2}/b", [
-        [ops.object, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
-        [ops.literal, "b"],
-      ]);
-      assertParse("callExpression", "files:foo/bar", [
-        [markers.global, "files:"],
-        [ops.literal, "foo/"],
-        [ops.literal, "bar"],
-      ]);
-    });
-    test("path and parentheses chains", () => {
-      assertParse("callExpression", "foo.js()/key", [
-        [[markers.reference, [ops.literal, "foo.js"]], undefined],
-        [ops.literal, "key"],
-      ]);
-      assertParse("callExpression", "tree/key()", [
-        [markers.reference, [ops.literal, "tree/"], [ops.literal, "key"]],
-        undefined,
-      ]);
-      assertParse("callExpression", "(tree)/", [
-        ops.unpack,
-        [markers.reference, [ops.literal, "tree/"]],
-      ]);
-      assertParse("callExpression", "fn()/key()", [
-        [
-          [[markers.global, "fn"], undefined],
-          [ops.literal, "key"],
-        ],
-        undefined,
-      ]);
-      assertParse("callExpression", "package:@weborigami/dropbox/auth(creds)", [
-        [
-          [markers.global, "package:"],
-          [ops.literal, "@weborigami/"],
-          [ops.literal, "dropbox/"],
-          [ops.literal, "auth"],
-        ],
-        [markers.reference, [ops.literal, "creds"]],
-      ]);
-    });
-    test("tagged templates", () => {
-      assertParse("callExpression", "indent`hello`", [
-        [markers.global, "indent"],
-        [ops.literal, ["hello"]],
-      ]);
-      assertParse("callExpression", "fn.js`Hello, world.`", [
-        [markers.reference, [ops.literal, "fn.js"]],
-        [ops.literal, ["Hello, world."]],
-      ]);
-    });
-    test("protocols", () => {
-      assertParse("callExpression", "files:src/assets", [
-        [markers.global, "files:"],
+  test("callExpression", () => {
+    assertParse("callExpression", "fn()", [[ops.builtin, "fn"], undefined]);
+    assertParse("callExpression", "foo.js(arg)", [
+      [ops.scope, "foo.js"],
+      [ops.scope, "arg"],
+    ]);
+    assertParse("callExpression", "fn(a, b)", [
+      [ops.builtin, "fn"],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
+    assertParse("callExpression", "foo.js( a , b )", [
+      [ops.scope, "foo.js"],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
+    assertParse("callExpression", "fn()(arg)", [
+      [[ops.builtin, "fn"], undefined],
+      [ops.scope, "arg"],
+    ]);
+    assertParse("callExpression", "tree/", [ops.unpack, [ops.scope, "tree/"]]);
+    assertParse("callExpression", "tree/foo/bar", [
+      ops.traverse,
+      [ops.scope, "tree/"],
+      [ops.literal, "foo/"],
+      [ops.literal, "bar"],
+    ]);
+    assertParse("callExpression", "tree/foo/bar/", [
+      ops.traverse,
+      [ops.scope, "tree/"],
+      [ops.literal, "foo/"],
+      [ops.literal, "bar/"],
+    ]);
+    assertParse("callExpression", "/foo/bar", [
+      ops.traverse,
+      [ops.rootDirectory, [ops.literal, "foo/"]],
+      [ops.literal, "bar"],
+    ]);
+    assertParse("callExpression", "foo.js()/key", [
+      ops.traverse,
+      [[ops.scope, "foo.js"], undefined],
+      [ops.literal, "key"],
+    ]);
+    assertParse("callExpression", "tree/key()", [
+      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
+      undefined,
+    ]);
+    assertParse("callExpression", "(tree)/", [ops.unpack, [ops.scope, "tree"]]);
+    assertParse("callExpression", "fn()/key()", [
+      [ops.traverse, [[ops.builtin, "fn"], undefined], [ops.literal, "key"]],
+      undefined,
+    ]);
+    assertParse("callExpression", "(foo.js())('arg')", [
+      [[ops.scope, "foo.js"], undefined],
+      [ops.literal, "arg"],
+    ]);
+    assertParse("callExpression", "fn('a')('b')", [
+      [
+        [ops.builtin, "fn"],
+        [ops.literal, "a"],
+      ],
+      [ops.literal, "b"],
+    ]);
+    assertParse("callExpression", "(foo.js())(a, b)", [
+      [[ops.scope, "foo.js"], undefined],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
+    assertParse("callExpression", "{ a: 1, b: 2}/b", [
+      ops.traverse,
+      [ops.object, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
+      [ops.literal, "b"],
+    ]);
+    assertParse("callExpression", "indent`hello`", [
+      [ops.builtin, "indent"],
+      [ops.literal, ["hello"]],
+    ]);
+    assertParse("callExpression", "fn.js`Hello, world.`", [
+      [ops.scope, "fn.js"],
+      [ops.literal, ["Hello, world."]],
+    ]);
+    assertParse("callExpression", "files:src/assets", [
+      ops.traverse,
+      [
+        [ops.builtin, "files:"],
         [ops.literal, "src/"],
-        [ops.literal, "assets"],
-      ]);
-      assertParse("callExpression", "new:(js:Date, '2025-01-01')", [
-        [markers.global, "new:"],
+      ],
+      [ops.literal, "assets"],
+    ]);
+    assertParse("callExpression", "new:(js:Date, '2025-01-01')", [
+      [ops.builtin, "new:"],
+      [
+        [ops.builtin, "js:"],
+        [ops.literal, "Date"],
+      ],
+      [ops.literal, "2025-01-01"],
+    ]);
+    assertParse("callExpression", "map(markdown, mdHtml)", [
+      [ops.builtin, "map"],
+      [ops.scope, "markdown"],
+      [ops.scope, "mdHtml"],
+    ]);
+    assertParse("callExpression", "package:@weborigami/dropbox/auth(creds)", [
+      [
+        ops.traverse,
         [
-          [markers.global, "js:"],
-          [ops.literal, "Date"],
+          [ops.builtin, "package:"],
+          [ops.literal, "@weborigami/"],
         ],
-        [ops.literal, "2025-01-01"],
-      ]);
-    });
+        [ops.literal, "dropbox/"],
+        [ops.literal, "auth"],
+      ],
+      [ops.scope, "creds"],
+    ]);
   });
 
   test("callExpression using property acccess", () => {
     assertParse("callExpression", "(foo).bar", [
-      markers.reference,
-      [ops.literal, "foo/"],
+      ops.traverse,
+      [ops.scope, "foo"],
       [ops.literal, "bar"],
     ]);
     assertParse("callExpression", "(foo).bar.baz", [
-      markers.reference,
-      [ops.literal, "foo/"],
-      [ops.literal, "bar/"],
+      ops.traverse,
+      [ops.traverse, [ops.scope, "foo"], [ops.literal, "bar"]],
       [ops.literal, "baz"],
     ]);
     assertParse("callExpression", "foo[bar]", [
-      markers.reference,
-      [ops.literal, "foo/"],
-      [markers.reference, [ops.literal, "bar"]],
+      ops.traverse,
+      [ops.scope, "foo/"],
+      [ops.scope, "bar"],
     ]);
-    assertParse(
-      "callExpression",
-      "Tree.map",
-      [markers.reference, [ops.literal, "Tree/"], [ops.literal, "map"]],
-      "jse"
-    );
   });
 
   test("commaExpression", () => {
     assertParse("commaExpression", "1", [ops.literal, 1]);
     assertParse("commaExpression", "a, b, c", [
       ops.comma,
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
-      [markers.reference, [ops.literal, "c"]],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+      [ops.scope, "c"],
     ]);
   });
 
@@ -355,19 +268,19 @@ describe("Origami parser", () => {
     assertParse("conditionalExpression", "1", [ops.literal, 1]);
     assertParse("conditionalExpression", "true ? 1 : 0", [
       ops.conditional,
-      [markers.reference, [ops.literal, "true"]],
+      [ops.scope, "true"],
       [ops.literal, 1],
       [ops.literal, 0],
     ]);
     assertParse("conditionalExpression", "false ? () => 1 : 0", [
       ops.conditional,
-      [markers.reference, [ops.literal, "false"]],
+      [ops.scope, "false"],
       [ops.lambda, [], [ops.lambda, [], [ops.literal, 1]]],
       [ops.literal, 0],
     ]);
     assertParse("conditionalExpression", "false ? =1 : 0", [
       ops.conditional,
-      [markers.reference, [ops.literal, "false"]],
+      [ops.scope, "false"],
       [ops.lambda, [], [ops.lambda, [[ops.literal, "_"]], [ops.literal, 1]]],
       [ops.literal, 0],
     ]);
@@ -381,12 +294,8 @@ describe("Origami parser", () => {
     ]);
     assertParse("equalityExpression", "a === b === c", [
       ops.strictEqual,
-      [
-        ops.strictEqual,
-        [markers.reference, [ops.literal, "a"]],
-        [markers.reference, [ops.literal, "b"]],
-      ],
-      [markers.reference, [ops.literal, "c"]],
+      [ops.strictEqual, [undetermined, "a"], [undetermined, "b"]],
+      [undetermined, "c"],
     ]);
     assertParse("equalityExpression", "1 !== 1", [
       ops.notStrictEqual,
@@ -454,8 +363,8 @@ Body`,
           [
             ops.getter,
             [
-              [markers.reference, [ops.literal, "index.ori"]],
-              [markers.reference, [ops.literal, "teamData.yaml"]],
+              [ops.scope, "index.ori"],
+              [ops.scope, "teamData.yaml"],
             ],
           ],
         ],
@@ -464,12 +373,9 @@ Body`,
           [
             ops.getter,
             [
-              [markers.global, "map"],
-              [markers.reference, [ops.literal, "images"]],
-              [
-                ops.object,
-                ["value", [markers.reference, [ops.literal, "thumbnail.js"]]],
-              ],
+              [ops.builtin, "map"],
+              [ops.scope, "images"],
+              [ops.object, ["value", [ops.scope, "thumbnail.js"]]],
             ],
           ],
         ],
@@ -477,54 +383,57 @@ Body`,
     );
 
     // Builtin on its own is the function itself, not a function call
-    assertParse("expression", "mdHtml:", [markers.global, "mdHtml:"]);
+    assertParse("expression", "mdHtml:", [ops.builtin, "mdHtml:"]);
 
-    // Consecutive slashes at start of something = comment
-    assertParse(
-      "expression",
-      "x //comment",
-      [markers.reference, [ops.literal, "x"]],
-      "jse",
-      false
-    );
+    // Consecutive slahes in a path are removed
+    assertParse("expression", "path//key", [
+      ops.traverse,
+      [ops.scope, "path/"],
+      [ops.literal, "key"],
+    ]);
 
+    // Single slash at start of something = absolute file path
+    assertParse("expression", "/path", [
+      ops.rootDirectory,
+      [ops.literal, "path"],
+    ]);
+
+    // Consecutive slashes at start of something = comment
+    assertParse("expression", "path //comment", [ops.scope, "path"], false);
     assertParse("expression", "page.ori(mdHtml:(about.md))", [
-      [markers.reference, [ops.literal, "page.ori"]],
+      [ops.scope, "page.ori"],
       [
-        [markers.global, "mdHtml:"],
-        [markers.reference, [ops.literal, "about.md"]],
+        [ops.builtin, "mdHtml:"],
+        [ops.scope, "about.md"],
       ],
     ]);
 
     // Slash on its own is the root folder
     assertParse("expression", "keys /", [
-      [markers.global, "keys"],
+      [ops.builtin, "keys"],
       [ops.rootDirectory],
     ]);
 
     assertParse("expression", "'Hello' -> test.orit", [
-      [markers.reference, [ops.literal, "test.orit"]],
+      [ops.scope, "test.orit"],
       [ops.literal, "Hello"],
     ]);
-    assertParse("expression", "obj.json", [
-      markers.reference,
-      [ops.literal, "obj.json"],
-    ]);
+    assertParse("expression", "obj.json", [ops.scope, "obj.json"]);
     assertParse("expression", "(fn a, b, c)", [
-      [markers.global, "fn"],
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
-      [markers.reference, [ops.literal, "c"]],
+      [ops.builtin, "fn"],
+      [undetermined, "a"],
+      [undetermined, "b"],
+      [undetermined, "c"],
     ]);
     assertParse("expression", "foo.bar('hello', 'world')", [
-      [markers.reference, [ops.literal, "foo.bar"]],
+      [ops.scope, "foo.bar"],
       [ops.literal, "hello"],
       [ops.literal, "world"],
     ]);
-    // assertParse("expression", "(key)('a')", [
-    //   [markers.reference, [ops.literal, "key"]],
-    //   [ops.literal, "a"],
-    // ]);
+    assertParse("expression", "(key)('a')", [
+      [ops.scope, "key"],
+      [ops.literal, "a"],
+    ]);
     assertParse("expression", "1", [ops.literal, 1]);
     assertParse("expression", "{ a: 1, b: 2 }", [
       ops.object,
@@ -532,49 +441,41 @@ Body`,
       ["b", [ops.literal, 2]],
     ]);
     assertParse("expression", "serve { index.html: 'hello' }", [
-      [markers.global, "serve"],
+      [ops.builtin, "serve"],
       [ops.object, ["index.html", [ops.literal, "hello"]]],
     ]);
     assertParse("expression", "fn =`x`", [
-      [markers.global, "fn"],
-      [
-        ops.lambda,
-        [[ops.literal, "_"]],
-        [ops.templateTree, [ops.literal, ["x"]]],
-      ],
+      [ops.builtin, "fn"],
+      [ops.lambda, [[ops.literal, "_"]], [ops.template, [ops.literal, ["x"]]]],
     ]);
     assertParse("expression", "copy app.js(formulas), files:snapshot", [
-      [markers.global, "copy"],
+      [ops.builtin, "copy"],
       [
-        [markers.reference, [ops.literal, "app.js"]],
-        [markers.reference, [ops.literal, "formulas"]],
+        [ops.scope, "app.js"],
+        [ops.scope, "formulas"],
       ],
       [
-        [markers.global, "files:"],
+        [ops.builtin, "files:"],
         [ops.literal, "snapshot"],
       ],
     ]);
     assertParse("expression", "map =`<li>${_}</li>`", [
-      [markers.global, "map"],
+      [ops.builtin, "map"],
       [
         ops.lambda,
         [[ops.literal, "_"]],
-        [
-          ops.templateTree,
-          [ops.literal, ["<li>", "</li>"]],
-          [markers.reference, [ops.literal, "_"]],
-        ],
+        [ops.template, [ops.literal, ["<li>", "</li>"]], [ops.scope, "_"]],
       ],
     ]);
     assertParse("expression", `https://example.com/about/`, [
-      [markers.global, "https:"],
+      [ops.builtin, "https:"],
       [ops.literal, "example.com/"],
       [ops.literal, "about/"],
     ]);
     assertParse("expression", "tag`Hello, ${name}!`", [
-      [markers.global, "tag"],
+      [ops.builtin, "tag"],
       [ops.literal, ["Hello, ", "!"]],
-      [ops.concat, [markers.reference, [ops.literal, "name"]]],
+      [ops.concat, [ops.scope, "name"]],
     ]);
     assertParse("expression", "(post, slug) => fn.js(post, slug)", [
       ops.lambda,
@@ -583,71 +484,52 @@ Body`,
         [ops.literal, "slug"],
       ],
       [
-        [markers.reference, [ops.literal, "fn.js"]],
-        [markers.reference, [ops.literal, "post"]],
-        [markers.reference, [ops.literal, "slug"]],
+        [ops.scope, "fn.js"],
+        [ops.scope, "post"],
+        [ops.scope, "slug"],
       ],
     ]);
     assertParse("expression", "keys ~", [
-      [markers.global, "keys"],
+      [ops.builtin, "keys"],
       [ops.homeDirectory],
     ]);
     assertParse("expression", "keys /Users/alice", [
-      [markers.global, "keys"],
-      [[ops.rootDirectory], [ops.literal, "Users/"], [ops.literal, "alice"]],
+      [ops.builtin, "keys"],
+      [
+        ops.traverse,
+        [ops.rootDirectory, [ops.literal, "Users/"]],
+        [ops.literal, "alice"],
+      ],
     ]);
 
     // Verify parser treatment of identifiers containing operators
     assertParse("expression", "a + b", [
       ops.addition,
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
+      [undetermined, "a"],
+      [undetermined, "b"],
     ]);
-    assertParse("expression", "a+b", [markers.reference, [ops.literal, "a+b"]]);
+    assertParse("expression", "a+b", [ops.scope, "a+b"]);
     assertParse("expression", "a - b", [
       ops.subtraction,
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
+      [undetermined, "a"],
+      [undetermined, "b"],
     ]);
-    assertParse("expression", "a-b", [markers.reference, [ops.literal, "a-b"]]);
-    assertParse("expression", "a&b", [markers.reference, [ops.literal, "a&b"]]);
+    assertParse("expression", "a-b", [ops.scope, "a-b"]);
+    assertParse("expression", "a&b", [ops.scope, "a&b"]);
     assertParse("expression", "a & b", [
       ops.bitwiseAnd,
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
+      [undetermined, "a"],
+      [undetermined, "b"],
     ]);
   });
 
-  test("frontMatterExpression", () => {
-    assertParse(
-      "frontMatterExpression",
-      `---
-(name) => _template()
----
-`,
-      [
-        ops.lambda,
-        [[ops.literal, "name"]],
-        [[markers.reference, [ops.literal, "_template"]], undefined],
-      ],
-      "jse",
-      false
-    );
-  });
-
   test("group", () => {
-    assertParse("group", "(hello)", [
-      markers.reference,
-      [ops.literal, "hello"],
-    ]);
-    assertParse("group", "(((nested)))", [
-      markers.reference,
-      [ops.literal, "nested"],
-    ]);
-    assertParse("group", "(fn())", [[markers.global, "fn"], undefined]);
+    assertParse("group", "(hello)", [ops.scope, "hello"]);
+    assertParse("group", "(((nested)))", [ops.scope, "nested"]);
+    assertParse("group", "(fn())", [[ops.builtin, "fn"], undefined]);
     assertParse("group", "(a -> b)", [
-      [markers.global, "b"],
-      [markers.reference, [ops.literal, "a"]],
+      [ops.builtin, "b"],
+      [ops.scope, "a"],
     ]);
   });
 
@@ -662,50 +544,50 @@ Body`,
   });
 
   test("identifier", () => {
-    assertParse("identifier", "abc", "abc", "shell", false);
-    assertParse("identifier", "index.html", "index.html", "shell", false);
-    assertParse("identifier", "foo\\ bar", "foo bar", "shell", false);
-    assertParse("identifier", "x-y-z", "x-y-z", "shell", false);
+    assertParse("identifier", "abc", "abc", false);
+    assertParse("identifier", "index.html", "index.html", false);
+    assertParse("identifier", "foo\\ bar", "foo bar", false);
+    assertParse("identifier", "x-y-z", "x-y-z", false);
   });
 
   test("implicitParenthesesCallExpression", () => {
     assertParse("implicitParenthesesCallExpression", "fn arg", [
-      [markers.global, "fn"],
-      [markers.reference, [ops.literal, "arg"]],
+      [ops.builtin, "fn"],
+      [undetermined, "arg"],
     ]);
     assertParse("implicitParenthesesCallExpression", "page.ori 'a', 'b'", [
-      [markers.reference, [ops.literal, "page.ori"]],
+      [ops.scope, "page.ori"],
       [ops.literal, "a"],
       [ops.literal, "b"],
     ]);
     assertParse("implicitParenthesesCallExpression", "fn a(b), c", [
-      [markers.global, "fn"],
+      [ops.builtin, "fn"],
       [
-        [markers.global, "a"],
-        [markers.reference, [ops.literal, "b"]],
+        [ops.builtin, "a"],
+        [ops.scope, "b"],
       ],
-      [markers.reference, [ops.literal, "c"]],
+      [undetermined, "c"],
     ]);
     assertParse("implicitParenthesesCallExpression", "(fn()) 'arg'", [
-      [[markers.global, "fn"], undefined],
+      [[ops.builtin, "fn"], undefined],
       [ops.literal, "arg"],
     ]);
     assertParse("implicitParenthesesCallExpression", "tree/key arg", [
-      [markers.reference, [ops.literal, "tree/"], [ops.literal, "key"]],
-      [markers.reference, [ops.literal, "arg"]],
+      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
+      [undetermined, "arg"],
     ]);
     assertParse("implicitParenthesesCallExpression", "foo.js bar.ori 'arg'", [
-      [markers.reference, [ops.literal, "foo.js"]],
+      [ops.scope, "foo.js"],
       [
-        [markers.reference, [ops.literal, "bar.ori"]],
+        [ops.scope, "bar.ori"],
         [ops.literal, "arg"],
       ],
     ]);
   });
 
   test("jsIdentifier", () => {
-    assertParse("jsIdentifier", "foo", [ops.literal, "foo"], "jse");
-    assertParse("jsIdentifier", "$Δelta", [ops.literal, "$Δelta"], "jse");
+    assertParse("jsIdentifier", "foo", "foo", false);
+    assertParse("jsIdentifier", "$Δelta", "$Δelta", false);
     assertThrows(
       "jsIdentifier",
       "1stCharacterIsNumber",
@@ -755,8 +637,8 @@ Body`,
   test("logicalAndExpression", () => {
     assertParse("logicalAndExpression", "true && false", [
       ops.logicalAnd,
-      [markers.reference, [ops.literal, "true"]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "false"]]],
+      [ops.scope, "true"],
+      [ops.lambda, [], [undetermined, "false"]],
     ]);
   });
 
@@ -768,9 +650,9 @@ Body`,
     ]);
     assertParse("logicalOrExpression", "false || false || true", [
       ops.logicalOr,
-      [markers.reference, [ops.literal, "false"]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "false"]]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "true"]]],
+      [ops.scope, "false"],
+      [ops.lambda, [], [undetermined, "false"]],
+      [ops.lambda, [], [undetermined, "true"]],
     ]);
     assertParse("logicalOrExpression", "1 || 2 && 0", [
       ops.logicalOr,
@@ -780,13 +662,7 @@ Body`,
   });
 
   test("multiLineComment", () => {
-    assertParse(
-      "multiLineComment",
-      "/*\nHello, world!\n*/",
-      null,
-      "jse",
-      false
-    );
+    assertParse("multiLineComment", "/*\nHello, world!\n*/", null, false);
   });
 
   test("multiplicativeExpression", () => {
@@ -808,31 +684,20 @@ Body`,
   });
 
   test("namespace", () => {
-    assertParse("namespace", "js:", [markers.global, "js:"]);
-  });
-
-  test("newExpression", () => {
-    assertParse("newExpression", "new Foo()", [
-      ops.construct,
-      [markers.reference, [ops.literal, "Foo"]],
-    ]);
-    assertParse("newExpression", "new:Foo()", [
-      ops.construct,
-      [markers.reference, [ops.literal, "Foo"]],
-    ]);
+    assertParse("namespace", "js:", [ops.builtin, "js:"]);
   });
 
   test("nullishCoalescingExpression", () => {
     assertParse("nullishCoalescingExpression", "a ?? b", [
       ops.nullishCoalescing,
-      [markers.reference, [ops.literal, "a"]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "b"]]],
+      [ops.scope, "a"],
+      [ops.lambda, [], [undetermined, "b"]],
     ]);
     assertParse("nullishCoalescingExpression", "a ?? b ?? c", [
       ops.nullishCoalescing,
-      [markers.reference, [ops.literal, "a"]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "b"]]],
-      [ops.lambda, [], [markers.reference, [ops.literal, "c"]]],
+      [ops.scope, "a"],
+      [ops.lambda, [], [undetermined, "b"]],
+      [ops.lambda, [], [undetermined, "c"]],
     ]);
   });
 
@@ -847,7 +712,7 @@ Body`,
     assertParse("objectLiteral", "{ a: 1, b }", [
       ops.object,
       ["a", [ops.literal, 1]],
-      ["b", [markers.reference, "b"]],
+      ["b", [ops.inherited, "b"]],
     ]);
     assertParse("objectLiteral", "{ sub: { a: 1 } }", [
       ops.object,
@@ -864,7 +729,7 @@ Body`,
     ]);
     assertParse("objectLiteral", "{ a = b, b = 2 }", [
       ops.object,
-      ["a", [ops.getter, [markers.reference, [ops.literal, "b"]]]],
+      ["a", [ops.getter, [ops.scope, "b"]]],
       ["b", [ops.literal, 2]],
     ]);
     assertParse(
@@ -875,7 +740,7 @@ Body`,
       }`,
       [
         ops.object,
-        ["a", [ops.getter, [markers.reference, [ops.literal, "b"]]]],
+        ["a", [ops.getter, [ops.scope, "b"]]],
         ["b", [ops.literal, 2]],
       ]
     );
@@ -891,7 +756,7 @@ Body`,
       ops.object,
       [
         "a",
-        [ops.object, ["b", [ops.getter, [[markers.global, "fn"], undefined]]]],
+        [ops.object, ["b", [ops.getter, [[ops.builtin, "fn"], undefined]]]],
       ],
     ]);
     assertParse("objectLiteral", "{ x = fn.js('a') }", [
@@ -901,28 +766,16 @@ Body`,
         [
           ops.getter,
           [
-            [markers.reference, [ops.literal, "fn.js"]],
+            [ops.scope, "fn.js"],
             [ops.literal, "a"],
           ],
         ],
       ],
     ]);
-    assertParse("objectLiteral", "{ a: 1, ...more, c: a }", [
-      [
-        ops.object,
-        ["a", [ops.literal, 1]],
-        ["c", [markers.reference, [ops.literal, "a"]]],
-        [
-          "_result",
-          [
-            ops.merge,
-            [ops.object, ["a", [ops.getter, [[ops.context, 1], "a"]]]],
-            [markers.reference, [ops.literal, "more"]],
-            [ops.object, ["c", [ops.getter, [[ops.context, 1], "c"]]]],
-          ],
-        ],
-      ],
-      "_result",
+    assertParse("objectLiteral", "{ a: 1, ...b }", [
+      ops.merge,
+      [ops.object, ["a", [ops.literal, 1]]],
+      [ops.scope, "b"],
     ]);
     assertParse("objectLiteral", "{ a: 1, ...{ b: 2 } }", [
       ops.object,
@@ -933,63 +786,22 @@ Body`,
       ops.object,
       ["(a)", [ops.literal, 1]],
     ]);
-    assertParse(
-      "objectLiteral",
-      "{ <path/to/file.txt> }",
-      [
-        ops.object,
-        [
-          "file.txt",
-          [
-            [ops.scope],
-            [ops.literal, "path/"],
-            [ops.literal, "to/"],
-            [ops.literal, "file.txt"],
-          ],
-        ],
-      ],
-      "jse"
-    );
   });
 
   test("objectEntry", () => {
-    assertParse("objectEntry", "foo", ["foo", [markers.reference, "foo"]]);
-    assertParse("objectEntry", "x: y", [
-      "x",
-      [markers.reference, [ops.literal, "y"]],
-    ]);
-    assertParse("objectEntry", "a: a", [
-      "a",
-      [markers.reference, [ops.literal, "a"]],
-    ]);
-    assertParse(
-      "objectEntry",
-      "<path/to/file.txt>",
-      [
-        "file.txt",
-        [
-          [ops.scope],
-          [ops.literal, "path/"],
-          [ops.literal, "to/"],
-          [ops.literal, "file.txt"],
-        ],
-      ],
-      "jse"
-    );
+    assertParse("objectEntry", "foo", ["foo", [ops.inherited, "foo"]]);
+    assertParse("objectEntry", "x: y", ["x", [ops.scope, "y"]]);
+    assertParse("objectEntry", "a: a", ["a", [ops.inherited, "a"]]);
     assertParse("objectEntry", "a: (a) => a", [
       "a",
-      [
-        ops.lambda,
-        [[ops.literal, "a"]],
-        [markers.reference, [ops.literal, "a"]],
-      ],
+      [ops.lambda, [[ops.literal, "a"]], [ops.scope, "a"]],
     ]);
     assertParse("objectEntry", "posts/: map(posts, post.ori)", [
       "posts/",
       [
-        [markers.global, "map"],
-        [markers.reference, [ops.literal, "posts"]],
-        [markers.reference, [ops.literal, "post.ori"]],
+        [ops.builtin, "map"],
+        [ops.inherited, "posts"],
+        [ops.scope, "post.ori"],
       ],
     ]);
   });
@@ -997,14 +809,14 @@ Body`,
   test("objectGetter", () => {
     assertParse("objectGetter", "data = obj.json", [
       "data",
-      [ops.getter, [markers.reference, [ops.literal, "obj.json"]]],
+      [ops.getter, [ops.scope, "obj.json"]],
     ]);
     assertParse("objectGetter", "foo = page.ori 'bar'", [
       "foo",
       [
         ops.getter,
         [
-          [markers.reference, [ops.literal, "page.ori"]],
+          [ops.scope, "page.ori"],
           [ops.literal, "bar"],
         ],
       ],
@@ -1020,31 +832,24 @@ Body`,
     assertParse("objectProperty", "x: fn('a')", [
       "x",
       [
-        [markers.global, "fn"],
+        [ops.builtin, "fn"],
         [ops.literal, "a"],
       ],
     ]);
   });
 
   test("objectPublicKey", () => {
-    assertParse("objectPublicKey", "a", "a", "jse", false);
-    assertParse("objectPublicKey", "markdown/", "markdown/", "jse", false);
-    assertParse("objectPublicKey", "foo\\ bar", "foo bar", "jse", false);
-  });
-
-  test("optionalChaining", () => {
-    assertParse("optionalChaining", "?.key", [
-      ops.optionalTraverse,
-      [ops.literal, "key"],
-    ]);
+    assertParse("objectPublicKey", "a", "a", false);
+    assertParse("objectPublicKey", "markdown/", "markdown/", false);
+    assertParse("objectPublicKey", "foo\\ bar", "foo bar", false);
   });
 
   test("parenthesesArguments", () => {
     assertParse("parenthesesArguments", "()", [undefined]);
     assertParse("parenthesesArguments", "(a, b, c)", [
-      [markers.reference, [ops.literal, "a"]],
-      [markers.reference, [ops.literal, "b"]],
-      [markers.reference, [ops.literal, "c"]],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+      [ops.scope, "c"],
     ]);
   });
 
@@ -1066,61 +871,46 @@ Body`,
   });
 
   test("pathArguments", () => {
-    assertParse("pathArguments", "/", [markers.traverse]);
+    assertParse("pathArguments", "/", [ops.traverse]);
     assertParse("pathArguments", "/tree", [
-      markers.traverse,
+      ops.traverse,
       [ops.literal, "tree"],
     ]);
     assertParse("pathArguments", "/tree/", [
-      markers.traverse,
+      ops.traverse,
       [ops.literal, "tree/"],
     ]);
   });
 
   test("pipelineExpression", () => {
-    assertParse("pipelineExpression", "foo", [
-      markers.reference,
-      [ops.literal, "foo"],
-    ]);
+    assertParse("pipelineExpression", "foo", [ops.scope, "foo"]);
     assertParse("pipelineExpression", "a -> b", [
-      [markers.global, "b"],
-      [markers.reference, [ops.literal, "a"]],
+      [ops.builtin, "b"],
+      [ops.scope, "a"],
     ]);
     assertParse("pipelineExpression", "input → one.js → two.js", [
-      [markers.reference, [ops.literal, "two.js"]],
+      [ops.scope, "two.js"],
       [
-        [markers.reference, [ops.literal, "one.js"]],
-        [markers.reference, [ops.literal, "input"]],
+        [ops.scope, "one.js"],
+        [ops.scope, "input"],
       ],
     ]);
     assertParse("pipelineExpression", "fn a -> b", [
-      [markers.global, "b"],
+      [ops.builtin, "b"],
       [
-        [markers.global, "fn"],
-        [markers.reference, [ops.literal, "a"]],
+        [ops.builtin, "fn"],
+        [undetermined, "a"],
       ],
     ]);
   });
 
   test("primary", () => {
-    assertParse("primary", "foo.js", [
-      markers.reference,
-      [ops.literal, "foo.js"],
-    ]);
+    assertParse("primary", "foo.js", [ops.scope, "foo.js"]);
     assertParse("primary", "[1, 2]", [
       ops.array,
       [ops.literal, 1],
       [ops.literal, 2],
     ]);
-    // Only in JSE
-    assertParse(
-      "primary",
-      "<index.html>",
-      [[ops.scope], [ops.literal, "index.html"]],
-      "jse",
-      false
-    );
-    assertThrows("primary", "<index.html>", `but "<" found`, 0, "shell");
   });
 
   test("program", () => {
@@ -1130,39 +920,37 @@ Body`,
 'Hello'
 `,
       [ops.literal, "Hello"],
-      "jse",
       false
     );
   });
 
   test("protocolExpression", () => {
-    assertParse("protocolExpression", "foo://bar/baz", [
-      [markers.global, "foo:"],
-      [ops.literal, "bar/"],
-      [ops.literal, "baz"],
+    assertParse("protocolExpression", "foo://bar", [
+      [ops.builtin, "foo:"],
+      [ops.literal, "bar"],
     ]);
     assertParse("protocolExpression", "http://example.com", [
-      [markers.global, "http:"],
+      [ops.builtin, "http:"],
       [ops.literal, "example.com"],
     ]);
     assertParse("protocolExpression", "https://example.com/about/", [
-      [markers.global, "https:"],
+      [ops.builtin, "https:"],
       [ops.literal, "example.com/"],
       [ops.literal, "about/"],
     ]);
     assertParse("protocolExpression", "https://example.com/about/index.html", [
-      [markers.global, "https:"],
+      [ops.builtin, "https:"],
       [ops.literal, "example.com/"],
       [ops.literal, "about/"],
       [ops.literal, "index.html"],
     ]);
     assertParse("protocolExpression", "http://localhost:5000/foo", [
-      [markers.global, "http:"],
+      [ops.builtin, "http:"],
       [ops.literal, "localhost:5000/"],
       [ops.literal, "foo"],
     ]);
     assertParse("protocolExpression", "files:///foo/bar.txt", [
-      [markers.global, "files:"],
+      [ops.builtin, "files:"],
       [ops.literal, "/"],
       [ops.literal, "foo/"],
       [ops.literal, "bar.txt"],
@@ -1171,15 +959,11 @@ Body`,
 
   test("qualifiedReference", () => {
     assertParse("qualifiedReference", "js:Date", [
-      [markers.global, "js:"],
+      [ops.builtin, "js:"],
       [ops.literal, "Date"],
     ]);
   });
 
-  test("regexLiteral", () => {
-    assertParse("regexLiteral", "/abc+/g", [ops.literal, /abc+/g]);
-  });
-
   test("relationalExpression", () => {
     assertParse("relationalExpression", "1 < 2", [
       ops.lessThan,
@@ -1203,15 +987,15 @@ Body`,
     ]);
   });
 
+  test("rootDirectory", () => {
+    assertParse("rootDirectory", "/", [ops.rootDirectory]);
+  });
+
   test("scopeReference", () => {
-    assertParse("scopeReference", "keys", [
-      markers.reference,
-      [ops.literal, "keys"],
-    ]);
-    assertParse("scopeReference", "greet.js", [
-      markers.reference,
-      [ops.literal, "greet.js"],
-    ]);
+    assertParse("scopeReference", "keys", [undetermined, "keys"]);
+    assertParse("scopeReference", "greet.js", [ops.scope, "greet.js"]);
+    // scopeReference checks whether a slash follows; hard to test in isolation
+    // assertParse("scopeReference", "markdown/", [ops.scope, "markdown"]);
   });
 
   test("shiftExpression", () => {
@@ -1236,40 +1020,30 @@ Body`,
     assertParse("shorthandFunction", "=message", [
       ops.lambda,
       [[ops.literal, "_"]],
-      [markers.reference, [ops.literal, "message"]],
+      [undetermined, "message"],
     ]);
     assertParse("shorthandFunction", "=`Hello, ${name}.`", [
       ops.lambda,
       [[ops.literal, "_"]],
-      [
-        ops.templateTree,
-        [ops.literal, ["Hello, ", "."]],
-        [markers.reference, [ops.literal, "name"]],
-      ],
+      [ops.template, [ops.literal, ["Hello, ", "."]], [ops.scope, "name"]],
     ]);
     assertParse("shorthandFunction", "=indent`hello`", [
       ops.lambda,
       [[ops.literal, "_"]],
       [
-        [markers.global, "indent"],
+        [ops.builtin, "indent"],
         [ops.literal, ["hello"]],
       ],
     ]);
   });
 
   test("singleLineComment", () => {
-    assertParse("singleLineComment", "// Hello, world!", null, "jse", false);
+    assertParse("singleLineComment", "// Hello, world!", null, false);
   });
 
   test("spreadElement", () => {
-    assertParse("spreadElement", "...a", [
-      ops.spread,
-      [markers.reference, [ops.literal, "a"]],
-    ]);
-    assertParse("spreadElement", "…a", [
-      ops.spread,
-      [markers.reference, [ops.literal, "a"]],
-    ]);
+    assertParse("spreadElement", "...a", [ops.spread, [ops.scope, "a"]]);
+    assertParse("spreadElement", "…a", [ops.spread, [ops.scope, "a"]]);
   });
 
   test("stringLiteral", () => {
@@ -1288,13 +1062,21 @@ Body`,
 
   test("templateBody", () => {
     assertParse("templateBody", "hello${foo}world", [
-      ops.templateIndent,
-      [ops.literal, ["hello", "world"]],
-      [markers.reference, [ops.literal, "foo"]],
+      ops.lambda,
+      [[ops.literal, "_"]],
+      [
+        ops.templateIndent,
+        [ops.literal, ["hello", "world"]],
+        [ops.scope, "foo"],
+      ],
     ]);
     assertParse("templateBody", "Documents can contain ` backticks", [
-      ops.templateIndent,
-      [ops.literal, ["Documents can contain ` backticks"]],
+      ops.lambda,
+      [[ops.literal, "_"]],
+      [
+        ops.templateIndent,
+        [ops.literal, ["Documents can contain ` backticks"]],
+      ],
     ]);
   });
 
@@ -1314,9 +1096,13 @@ title: Title goes here
 ---
 Body text`,
       [
-        ops.object,
-        ["title", [ops.literal, "Title goes here"]],
-        ["@text", [ops.templateIndent, [ops.literal, ["Body text"]]]],
+        ops.document,
+        [ops.literal, { title: "Title goes here" }],
+        [
+          ops.lambda,
+          [[ops.literal, "_"]],
+          [ops.templateIndent, [ops.literal, ["Body text"]]],
+        ],
       ]
     );
   });
@@ -1338,9 +1124,16 @@ Body text`,
         [
           "@text",
           [
-            ops.templateIndent,
-            [ops.literal, ["<h1>", "</h1>\n"]],
-            [markers.reference, [ops.literal, "title"]],
+            [
+              ops.lambda,
+              [[ops.literal, "_"]],
+              [
+                ops.templateIndent,
+                [ops.literal, ["<h1>", "</h1>\n"]],
+                [ops.scope, "title"],
+              ],
+            ],
+            undefined,
           ],
         ],
       ]
@@ -1349,52 +1142,36 @@ Body text`,
 
   test("templateLiteral", () => {
     assertParse("templateLiteral", "`Hello, world.`", [
-      ops.templateTree,
+      ops.template,
       [ops.literal, ["Hello, world."]],
     ]);
-    assertParse(
-      "templateLiteral",
-      "`Hello, world.`",
-      [ops.templateStandard, [ops.literal, ["Hello, world."]]],
-      "jse"
-    );
     assertParse("templateLiteral", "`foo ${x} bar`", [
-      ops.templateTree,
+      ops.template,
       [ops.literal, ["foo ", " bar"]],
-      [markers.reference, [ops.literal, "x"]],
+      [ops.scope, "x"],
     ]);
     assertParse("templateLiteral", "`${`nested`}`", [
-      ops.templateTree,
+      ops.template,
       [ops.literal, ["", ""]],
-      [ops.templateTree, [ops.literal, ["nested"]]],
+      [ops.template, [ops.literal, ["nested"]]],
     ]);
     assertParse("templateLiteral", "`${ map:(people, =`${name}`) }`", [
-      ops.templateTree,
+      ops.template,
       [ops.literal, ["", ""]],
       [
-        [markers.global, "map:"],
-        [markers.reference, [ops.literal, "people"]],
+        [ops.builtin, "map:"],
+        [ops.scope, "people"],
         [
           ops.lambda,
           [[ops.literal, "_"]],
-          [
-            ops.templateTree,
-            [ops.literal, ["", ""]],
-            [markers.reference, [ops.literal, "name"]],
-          ],
+          [ops.template, [ops.literal, ["", ""]], [ops.scope, "name"]],
         ],
       ],
     ]);
   });
 
   test("templateSubtitution", () => {
-    assertParse(
-      "templateSubstitution",
-      "${foo}",
-      [markers.reference, [ops.literal, "foo"]],
-      "shell",
-      false
-    );
+    assertParse("templateSubstitution", "${foo}", [ops.scope, "foo"], false);
   });
 
   test("whitespace block", () => {
@@ -1405,7 +1182,6 @@ Body text`,
   // Second comment
      `,
       null,
-      "jse",
       false
     );
   });
@@ -1413,7 +1189,7 @@ Body text`,
   test("unaryExpression", () => {
     assertParse("unaryExpression", "!true", [
       ops.logicalNot,
-      [markers.reference, [ops.literal, "true"]],
+      [undetermined, "true"],
     ]);
     assertParse("unaryExpression", "+1", [ops.unaryPlus, [ops.literal, 1]]);
     assertParse("unaryExpression", "-2", [ops.unaryMinus, [ops.literal, 2]]);
@@ -1421,16 +1197,9 @@ Body text`,
   });
 });
 
-function assertParse(
-  startRule,
-  source,
-  expected,
-  mode = "shell",
-  checkLocation = true
-) {
+function assertParse(startRule, source, expected, checkLocation = true) {
   const code = parse(source, {
     grammarSource: { text: source },
-    mode,
     startRule,
   });
 
@@ -1458,11 +1227,10 @@ function assertCodeLocations(code) {
   }
 }
 
-function assertThrows(startRule, source, message, position, mode = "shell") {
+function assertThrows(startRule, source, message, position) {
   try {
     parse(source, {
       grammarSource: { text: source },
-      mode,
       startRule,
     });
   } catch (/** @type {any} */ error) {